@chr33s/pdf-restructure 5.0.0 → 5.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chr33s/pdf-restructure",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "Declaratively encode and decode binary data",
   "type": "module",
   "sideEffects": false,

package/test/array.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { Array as ArrayT, DecodeStream, Pointer, uint16, uint8 } from "../src/index.js";
-
-describe("Array", () => {
-  describe("decode", () => {
-    test("should decode fixed length", () => {
-      const array = new ArrayT(uint8, 4);
-      expect(array.fromBuffer(new Uint8Array([1, 2, 3, 4, 5]))).to.deep.equal([1, 2, 3, 4]);
-    });
-
-    test("should decode fixed amount of bytes", () => {
-      const array = new ArrayT(uint16, 4, "bytes");
-      expect(array.fromBuffer(new Uint8Array([1, 2, 3, 4, 5]))).to.deep.equal([258, 772]);
-    });
-
-    test("should decode length from parent key", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 2, 3, 4, 5]));
-      const array = new ArrayT(uint8, "len");
-      expect(array.decode(stream, { len: 4 })).to.deep.equal([1, 2, 3, 4]);
-    });
-
-    test("should decode amount of bytes from parent key", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 2, 3, 4, 5]));
-      const array = new ArrayT(uint16, "len", "bytes");
-      expect(array.decode(stream, { len: 4 })).to.deep.equal([258, 772]);
-    });
-
-    test("should decode length as number before array", () => {
-      const array = new ArrayT(uint8, uint8);
-      expect(array.fromBuffer(new Uint8Array([4, 1, 2, 3, 4, 5]))).to.deep.equal([1, 2, 3, 4]);
-    });
-
-    test("should decode amount of bytes as number before array", () => {
-      const array = new ArrayT(uint16, uint8, "bytes");
-      expect(array.fromBuffer(new Uint8Array([4, 1, 2, 3, 4, 5]))).to.deep.equal([258, 772]);
-    });
-
-    test("should decode length from function", () => {
-      const array = new ArrayT(uint8, () => 4);
-      expect(array.fromBuffer(new Uint8Array([1, 2, 3, 4, 5]))).to.deep.equal([1, 2, 3, 4]);
-    });
-
-    test("should decode amount of bytes from function", () => {
-      const array = new ArrayT(uint16, () => 4, "bytes");
-      expect(array.fromBuffer(new Uint8Array([1, 2, 3, 4, 5]))).to.deep.equal([258, 772]);
-    });
-
-    test("should decode to the end of the parent if no length is given", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 2, 3, 4, 5]));
-      const array = new ArrayT(uint8);
-      expect(array.decode(stream, { _length: 4, _startOffset: 0 })).to.deep.equal([1, 2, 3, 4]);
-    });
-
-    test("should decode to the end of the stream if no parent and length is given", () => {
-      const array = new ArrayT(uint8);
-      expect(array.fromBuffer(new Uint8Array([1, 2, 3, 4]))).to.deep.equal([1, 2, 3, 4]);
-    });
-  });
-
-  describe("size", () => {
-    test("should use array length", () => {
-      const array = new ArrayT(uint8, 10);
-      expect(array.size([1, 2, 3, 4])).to.equal(4);
-    });
-
-    test("should add size of length field before string", () => {
-      const array = new ArrayT(uint8, uint8);
-      expect(array.size([1, 2, 3, 4])).to.equal(5);
-    });
-
-    test("should use defined length if no value given", () => {
-      const array = new ArrayT(uint8, 10);
-      expect(array.size()).to.equal(10);
-    });
-  });
-
-  describe("encode", () => {
-    test("should encode using array length", () => {
-      const array = new ArrayT(uint8, 10);
-      expect(array.toBuffer([1, 2, 3, 4])).to.deep.equal(new Uint8Array([1, 2, 3, 4]));
-    });
-
-    test("should encode length as number before array", () => {
-      const array = new ArrayT(uint8, uint8);
-      expect(array.toBuffer([1, 2, 3, 4])).to.deep.equal(new Uint8Array([4, 1, 2, 3, 4]));
-    });
-
-    test("should add pointers after array if length is encoded at start", () => {
-      const array = new ArrayT(new Pointer(uint8, uint8), uint8);
-      expect(array.toBuffer([1, 2, 3, 4])).to.deep.equal(
-        new Uint8Array([4, 5, 6, 7, 8, 1, 2, 3, 4]),
-      );
-    });
-  });
-});

package/test/bitfield.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { Bitfield, uint8 } from "../src/index.js";
-
-describe("Bitfield", () => {
-  const bitfield = new Bitfield(uint8, [
-    "Jack",
-    "Kack",
-    "Lack",
-    "Mack",
-    "Nack",
-    "Oack",
-    "Pack",
-    "Quack",
-  ]);
-  const JACK = 1 << 0;
-  const MACK = 1 << 3;
-  const NACK = 1 << 4;
-  const PACK = 1 << 6;
-  const QUACK = 1 << 7;
-
-  test("should have the right size", () => {
-    expect(bitfield.size()).to.equal(1);
-  });
-
-  test("should decode", () => {
-    expect(bitfield.fromBuffer(new Uint8Array([JACK | MACK | PACK | NACK | QUACK]))).to.deep.equal({
-      Jack: true,
-      Kack: false,
-      Lack: false,
-      Mack: true,
-      Nack: true,
-      Oack: false,
-      Pack: true,
-      Quack: true,
-    });
-  });
-
-  test("should encode", () => {
-    expect(
-      bitfield.toBuffer({
-        Jack: true,
-        Kack: false,
-        Lack: false,
-        Mack: true,
-        Nack: true,
-        Oack: false,
-        Pack: true,
-        Quack: true,
-      }),
-    ).to.deep.equal(new Uint8Array([JACK | MACK | PACK | NACK | QUACK]));
-  });
-});

package/test/boolean.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { Boolean as BooleanT, uint8 } from "../src/index.js";
-
-describe("Boolean", () => {
-  describe("decode", () => {
-    test("should decode 0 as false", () => {
-      const boolean = new BooleanT(uint8);
-      expect(boolean.fromBuffer(new Uint8Array([0]))).to.equal(false);
-    });
-
-    test("should decode 1 as true", () => {
-      const boolean = new BooleanT(uint8);
-      expect(boolean.fromBuffer(new Uint8Array([1]))).to.equal(true);
-    });
-  });
-
-  describe("size", () => {
-    test("should return given type size", () => {
-      const boolean = new BooleanT(uint8);
-      expect(boolean.size()).to.equal(1);
-    });
-  });
-
-  describe("encode", () => {
-    test("should encode false as 0", () => {
-      const boolean = new BooleanT(uint8);
-      expect(boolean.toBuffer(false)).to.deep.equal(new Uint8Array([0]));
-    });
-
-    test("should encode true as 1", () => {
-      const boolean = new BooleanT(uint8);
-      expect(boolean.toBuffer(true)).to.deep.equal(new Uint8Array([1]));
-    });
-  });
-});

package/test/buffer.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { Buffer as BufferT, DecodeStream, EncodeStream, uint8 } from "../src/index.js";
-
-describe("Buffer", () => {
-  describe("decode", () => {
-    test("should decode", () => {
-      const stream = new DecodeStream(new Uint8Array([0xab, 0xff, 0x1f, 0xb6]));
-      const buf = new BufferT(2);
-      expect(buf.decode(stream)).to.deep.equal(new Uint8Array([0xab, 0xff]));
-      expect(buf.decode(stream)).to.deep.equal(new Uint8Array([0x1f, 0xb6]));
-    });
-
-    test("should decode with parent key length", () => {
-      const stream = new DecodeStream(new Uint8Array([0xab, 0xff, 0x1f, 0xb6]));
-      const buf = new BufferT("len");
-      expect(buf.decode(stream, { len: 3 })).to.deep.equal(new Uint8Array([0xab, 0xff, 0x1f]));
-      expect(buf.decode(stream, { len: 1 })).to.deep.equal(new Uint8Array([0xb6]));
-    });
-  });
-
-  describe("size", () => {
-    test("should return size", () => {
-      const buf = new BufferT(2);
-      expect(buf.size(new Uint8Array([0xab, 0xff]))).to.equal(2);
-    });
-
-    test("should use defined length if no value given", () => {
-      const array = new BufferT(10);
-      expect(array.size()).to.equal(10);
-    });
-  });
-
-  describe("encode", () => {
-    test("should encode", () => {
-      const buf = new BufferT(2);
-      const stream = new EncodeStream(new Uint8Array(4));
-      buf.encode(stream, new Uint8Array([0xab, 0xff]));
-      buf.encode(stream, new Uint8Array([0x1f, 0xb6]));
-      expect(stream.buffer).to.deep.equal(new Uint8Array([0xab, 0xff, 0x1f, 0xb6]));
-    });
-
-    test("should encode length before buffer", () => {
-      const buf = new BufferT(uint8);
-      const stream = new EncodeStream(new Uint8Array(3));
-      buf.encode(stream, new Uint8Array([0xab, 0xff]));
-      expect(stream.buffer).to.deep.equal(new Uint8Array([2, 0xab, 0xff]));
-    });
-  });
-});

package/test/decode-stream.test.ts

@@ -1,104 +0,0 @@
-import { Buffer } from "node:buffer";
-import { describe, expect, test } from "vitest";
-import { DecodeStream } from "../src/index.js";
-
-describe("DecodeStream", () => {
-  test("should read a buffer", () => {
-    const buf = Buffer.from([1, 2, 3]);
-    const stream = new DecodeStream(buf);
-    expect(stream.readBuffer(buf.length)).to.deep.equal(Buffer.from([1, 2, 3]));
-  });
-
-  test("should readUInt16BE", () => {
-    const buf = Buffer.from([0xab, 0xcd]);
-    const stream = new DecodeStream(buf);
-    expect(stream.readUInt16BE()).to.equal(0xabcd);
-  });
-
-  test("should readUInt16LE", () => {
-    const buf = Buffer.from([0xab, 0xcd]);
-    const stream = new DecodeStream(buf);
-    expect(stream.readUInt16LE()).to.equal(0xcdab);
-  });
-
-  test("should readUInt24BE", () => {
-    const buf = Buffer.from([0xab, 0xcd, 0xef]);
-    const stream = new DecodeStream(buf);
-    expect(stream.readUInt24BE()).to.equal(0xabcdef);
-  });
-
-  test("should readUInt24LE", () => {
-    const buf = Buffer.from([0xab, 0xcd, 0xef]);
-    const stream = new DecodeStream(buf);
-    expect(stream.readUInt24LE()).to.equal(0xefcdab);
-  });
-
-  test("should readInt24BE", () => {
-    const buf = Buffer.from([0xff, 0xab, 0x24]);
-    const stream = new DecodeStream(buf);
-    expect(stream.readInt24BE()).to.equal(-21724);
-  });
-
-  test("should readInt24LE", () => {
-    const buf = Buffer.from([0x24, 0xab, 0xff]);
-    const stream = new DecodeStream(buf);
-    expect(stream.readInt24LE()).to.equal(-21724);
-  });
-
-  describe("readString", () => {
-    test("should decode ascii by default", () => {
-      const buf = Buffer.from("some text", "ascii");
-      const stream = new DecodeStream(buf);
-      expect(stream.readString(buf.length)).to.equal("some text");
-    });
-
-    test("should decode ascii", () => {
-      const buf = Buffer.from("some text", "ascii");
-      const stream = new DecodeStream(buf);
-      expect(stream.readString(buf.length, "ascii")).to.equal("some text");
-    });
-
-    test("should decode utf8", () => {
-      const buf = Buffer.from("unicode! 👍", "utf8");
-      const stream = new DecodeStream(buf);
-      expect(stream.readString(buf.length, "utf8")).to.equal("unicode! 👍");
-    });
-
-    test("should decode utf16le", () => {
-      const buf = Buffer.from("unicode! 👍", "utf16le");
-      const stream = new DecodeStream(buf);
-      expect(stream.readString(buf.length, "utf16le")).to.equal("unicode! 👍");
-    });
-
-    test("should decode ucs2", () => {
-      const buf = Buffer.from("unicode! 👍", "ucs2");
-      const stream = new DecodeStream(buf);
-      expect(stream.readString(buf.length, "ucs2")).to.equal("unicode! 👍");
-    });
-
-    test("should decode utf16be", () => {
-      const buf = Buffer.from("unicode! 👍", "utf16le");
-      for (let i = 0; i < buf.length - 1; i += 2) {
-        const byte = buf[i];
-        buf[i] = buf[i + 1];
-        buf[i + 1] = byte;
-      }
-      const stream = new DecodeStream(buf);
-      expect(stream.readString(buf.length, "utf16be")).to.equal("unicode! 👍");
-    });
-
-    test("should decode macroman", () => {
-      const buf = Buffer.from([
-        0x8a, 0x63, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x63, 0x68, 0x87, 0x72, 0x61, 0x63,
-        0x74, 0x65, 0x72, 0x73,
-      ]);
-      const stream = new DecodeStream(buf);
-      expect(stream.readString(buf.length, "mac")).to.equal("äccented cháracters");
-    });
-
-    test("should return a buffer for unsupported encodings", () => {
-      const stream = new DecodeStream(Buffer.from([1, 2, 3]));
-      expect(stream.readString(3, "unsupported")).to.deep.equal(Buffer.from([1, 2, 3]));
-    });
-  });
-});

package/test/encode-stream.test.ts

@@ -1,111 +0,0 @@
-import { Buffer } from "node:buffer";
-import { describe, expect, test } from "vitest";
-import { EncodeStream } from "../src/index.js";
-
-describe("EncodeStream", () => {
-  test("should write a buffer", () => {
-    const stream = new EncodeStream(new Uint8Array(3));
-    stream.writeBuffer(new Uint8Array([1, 2, 3]));
-    expect(stream.buffer).to.deep.equal(new Uint8Array([1, 2, 3]));
-  });
-
-  test("should writeUInt16BE", () => {
-    const stream = new EncodeStream(new Uint8Array(2));
-    stream.writeUInt16BE(0xabcd);
-    expect(stream.buffer).to.deep.equal(new Uint8Array([0xab, 0xcd]));
-  });
-
-  test("should writeUInt16LE", () => {
-    const stream = new EncodeStream(new Uint8Array(2));
-    stream.writeUInt16LE(0xcdab);
-    expect(stream.buffer).to.deep.equal(new Uint8Array([0xab, 0xcd]));
-  });
-
-  test("should writeUInt24BE", () => {
-    const stream = new EncodeStream(new Uint8Array(3));
-    stream.writeUInt24BE(0xabcdef);
-    expect(stream.buffer).to.deep.equal(new Uint8Array([0xab, 0xcd, 0xef]));
-  });
-
-  test("should writeUInt24LE", () => {
-    const stream = new EncodeStream(new Uint8Array(3));
-    stream.writeUInt24LE(0xabcdef);
-    expect(stream.buffer).to.deep.equal(new Uint8Array([0xef, 0xcd, 0xab]));
-  });
-
-  test("should writeInt24BE", () => {
-    const stream = new EncodeStream(new Uint8Array(6));
-    stream.writeInt24BE(-21724);
-    stream.writeInt24BE(0xabcdef);
-    expect(stream.buffer).to.deep.equal(new Uint8Array([0xff, 0xab, 0x24, 0xab, 0xcd, 0xef]));
-  });
-
-  test("should writeInt24LE", () => {
-    const stream = new EncodeStream(new Uint8Array(6));
-    stream.writeInt24LE(-21724);
-    stream.writeInt24LE(0xabcdef);
-    expect(stream.buffer).to.deep.equal(new Uint8Array([0x24, 0xab, 0xff, 0xef, 0xcd, 0xab]));
-  });
-
-  test("should fill", () => {
-    const stream = new EncodeStream(new Uint8Array(5));
-    stream.fill(10, 5);
-    expect(stream.buffer).to.deep.equal(new Uint8Array([10, 10, 10, 10, 10]));
-  });
-
-  describe("writeString", () => {
-    test("should encode ascii by default", () => {
-      const expected = Buffer.from("some text", "ascii");
-      const stream = new EncodeStream(new Uint8Array(expected.length));
-      stream.writeString("some text");
-      expect(stream.buffer).to.deep.equal(new Uint8Array(expected));
-    });
-
-    test("should encode ascii", () => {
-      const expected = Buffer.from("some text", "ascii");
-      const stream = new EncodeStream(new Uint8Array(expected.length));
-      stream.writeString("some text", "ascii");
-      expect(stream.buffer).to.deep.equal(new Uint8Array(expected));
-    });
-
-    test("should encode utf8", () => {
-      const expected = Buffer.from("unicode! 👍", "utf8");
-      const stream = new EncodeStream(new Uint8Array(expected.length));
-      stream.writeString("unicode! 👍", "utf8");
-      expect(stream.buffer).to.deep.equal(new Uint8Array(expected));
-    });
-
-    test("should encode utf16le", () => {
-      const expected = Buffer.from("unicode! 👍", "utf16le");
-      const stream = new EncodeStream(new Uint8Array(expected.length));
-      stream.writeString("unicode! 👍", "utf16le");
-      expect(stream.buffer).to.deep.equal(new Uint8Array(expected));
-    });
-
-    test("should encode ucs2", () => {
-      const expected = Buffer.from("unicode! 👍", "ucs2");
-      const stream = new EncodeStream(new Uint8Array(expected.length));
-      stream.writeString("unicode! 👍", "ucs2");
-      expect(stream.buffer).to.deep.equal(new Uint8Array(expected));
-    });
-
-    test("should encode utf16be", () => {
-      const expected = Buffer.from("unicode! 👍", "utf16le");
-      for (let i = 0; i < expected.length - 1; i += 2) {
-        const byte = expected[i];
-        expected[i] = expected[i + 1];
-        expected[i + 1] = byte;
-      }
-      const stream = new EncodeStream(new Uint8Array(expected.length));
-      stream.writeString("unicode! 👍", "utf16be");
-      expect(stream.buffer).to.deep.equal(new Uint8Array(expected));
-    });
-
-    test("should throw for unsupported encoding", () => {
-      const stream = new EncodeStream(new Uint8Array(19));
-      expect(() => stream.writeString("äccented cháracters", "mac")).to.throw(
-        "Unsupported encoding: mac",
-      );
-    });
-  });
-});

package/test/enum.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { DecodeStream, EncodeStream, Enum, uint8 } from "../src/index.js";
-
-describe("Enum", () => {
-  const e = new Enum(uint8, ["foo", "bar", "baz"]);
-
-  test("should have the right size", () => {
-    expect(e.size()).to.equal(1);
-  });
-
-  test("should decode", () => {
-    const stream = new DecodeStream(new Uint8Array([1, 2, 0]));
-    expect(e.decode(stream)).to.equal("bar");
-    expect(e.decode(stream)).to.equal("baz");
-    expect(e.decode(stream)).to.equal("foo");
-  });
-
-  test("should encode", () => {
-    const stream = new EncodeStream(new Uint8Array(3));
-    e.encode(stream, "bar");
-    e.encode(stream, "baz");
-    e.encode(stream, "foo");
-    expect(stream.buffer).to.deep.equal(new Uint8Array([1, 2, 0]));
-  });
-
-  test("should throw on unknown option", () => {
-    const stream = new EncodeStream(new Uint8Array(1));
-    expect(() => e.encode(stream, "unknown")).to.throw(/unknown option/i);
-  });
-});

package/test/lazy-array.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { DecodeStream, EncodeStream, LazyArray as LazyArrayT, uint8 } from "../src/index.js";
-
-describe("LazyArray", () => {
-  describe("decode", () => {
-    test("should decode items lazily", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 2, 3, 4, 5]));
-      const array = new LazyArrayT(uint8, 4);
-
-      const arr = array.decode(stream);
-      expect(arr).to.not.be.an("array");
-      expect(arr).to.have.length(4);
-      expect(stream.pos).to.equal(4);
-
-      expect(arr.get(0)).to.equal(1);
-      expect(arr.get(1)).to.equal(2);
-      expect(arr.get(2)).to.equal(3);
-      expect(arr.get(3)).to.equal(4);
-
-      expect(arr.get(-1)).to.equal(undefined);
-      expect(arr.get(5)).to.equal(undefined);
-    });
-
-    test("should be able to convert to an array", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 2, 3, 4, 5]));
-      const array = new LazyArrayT(uint8, 4);
-      const arr = array.decode(stream);
-
-      expect(arr.toArray()).to.deep.equal([1, 2, 3, 4]);
-    });
-
-    test("should have an inspect method", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 2, 3, 4, 5]));
-      const array = new LazyArrayT(uint8, 4);
-      const arr = array.decode(stream);
-
-      expect(arr.inspect()).to.equal("[1,2,3,4]");
-    });
-
-    test("should decode length as number before array", () => {
-      const stream = new DecodeStream(new Uint8Array([4, 1, 2, 3, 4, 5]));
-      const array = new LazyArrayT(uint8, uint8);
-      const arr = array.decode(stream);
-
-      expect(arr.toArray()).to.deep.equal([1, 2, 3, 4]);
-    });
-  });
-
-  describe("size", () => {
-    test("should work with LazyArrays", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 2, 3, 4, 5]));
-      const array = new LazyArrayT(uint8, 4);
-      const arr = array.decode(stream);
-
-      expect(array.size(arr)).to.equal(4);
-    });
-  });
-
-  describe("encode", () => {
-    test("should work with LazyArrays", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 2, 3, 4, 5]));
-      const array = new LazyArrayT(uint8, 4);
-      const arr = array.decode(stream);
-
-      const enc = new EncodeStream(new Uint8Array(array.size(arr)));
-      array.encode(enc, arr);
-      expect(enc.buffer).to.deep.equal(new Uint8Array([1, 2, 3, 4]));
-    });
-  });
-});