@chr33s/pdf-restructure 5.0.0

package/test/encode-stream.test.ts

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,70 @@
+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]));
+    });
+  });
+});

package/test/number.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, test } from "vitest";
+import {
+  DecodeStream,
+  double,
+  doublebe,
+  doublele,
+  EncodeStream,
+  fixed16,
+  fixed16be,
+  fixed16le,
+  fixed32,
+  fixed32be,
+  fixed32le,
+  float,
+  floatbe,
+  floatle,
+  int16,
+  int16be,
+  int16le,
+  int24,
+  int24be,
+  int24le,
+  int32,
+  int32be,
+  int32le,
+  int8,
+  uint16,
+  uint16be,
+  uint16le,
+  uint24,
+  uint24be,
+  uint24le,
+  uint32,
+  uint32be,
+  uint32le,
+  uint8,
+} from "../src/index.js";
+
+type IntegerCase = {
+  name: string;
+  type: any;
+  buffer: number[];
+  expected: number[];
+  size: number;
+};
+
+const integerCases: IntegerCase[] = [
+  { name: "uint8", type: uint8, buffer: [0xab, 0xff], expected: [0xab, 0xff], size: 1 },
+  { name: "uint16be", type: uint16be, buffer: [0xab, 0xff], expected: [0xabff], size: 2 },
+  { name: "uint16le", type: uint16le, buffer: [0xff, 0xab], expected: [0xabff], size: 2 },
+  { name: "uint24be", type: uint24be, buffer: [0xff, 0xab, 0x24], expected: [0xffab24], size: 3 },
+  { name: "uint24le", type: uint24le, buffer: [0x24, 0xab, 0xff], expected: [0xffab24], size: 3 },
+  {
+    name: "uint32be",
+    type: uint32be,
+    buffer: [0xff, 0xab, 0x24, 0xbf],
+    expected: [0xffab24bf],
+    size: 4,
+  },
+  {
+    name: "uint32le",
+    type: uint32le,
+    buffer: [0xbf, 0x24, 0xab, 0xff],
+    expected: [0xffab24bf],
+    size: 4,
+  },
+  { name: "int8", type: int8, buffer: [0x7f, 0xff], expected: [127, -1], size: 1 },
+  { name: "int16be", type: int16be, buffer: [0xff, 0xab], expected: [-85], size: 2 },
+  { name: "int16le", type: int16le, buffer: [0xab, 0xff], expected: [-85], size: 2 },
+  { name: "int24be", type: int24be, buffer: [0xff, 0xab, 0x24], expected: [-21724], size: 3 },
+  { name: "int24le", type: int24le, buffer: [0x24, 0xab, 0xff], expected: [-21724], size: 3 },
+  {
+    name: "int32be",
+    type: int32be,
+    buffer: [0xff, 0xab, 0x24, 0xbf],
+    expected: [-5561153],
+    size: 4,
+  },
+  {
+    name: "int32le",
+    type: int32le,
+    buffer: [0xbf, 0x24, 0xab, 0xff],
+    expected: [-5561153],
+    size: 4,
+  },
+];
+
+type FloatCase = {
+  name: string;
+  type: any;
+  buffer: number[];
+  expected: number;
+  size: number;
+  precision?: number;
+};
+
+const floatCases: FloatCase[] = [
+  {
+    name: "floatbe",
+    type: floatbe,
+    buffer: [0x43, 0x7a, 0x8c, 0xcd],
+    expected: 250.55,
+    size: 4,
+    precision: 0.005,
+  },
+  {
+    name: "floatle",
+    type: floatle,
+    buffer: [0xcd, 0x8c, 0x7a, 0x43],
+    expected: 250.55,
+    size: 4,
+    precision: 0.005,
+  },
+  {
+    name: "doublebe",
+    type: doublebe,
+    buffer: [0x40, 0x93, 0x4a, 0x3d, 0x70, 0xa3, 0xd7, 0x0a],
+    expected: 1234.56,
+    size: 8,
+  },
+  {
+    name: "doublele",
+    type: doublele,
+    buffer: [0x0a, 0xd7, 0xa3, 0x70, 0x3d, 0x4a, 0x93, 0x40],
+    expected: 1234.56,
+    size: 8,
+  },
+  {
+    name: "fixed16be",
+    type: fixed16be,
+    buffer: [0x19, 0x57],
+    expected: 25.34,
+    size: 2,
+    precision: 0.005,
+  },
+  {
+    name: "fixed16le",
+    type: fixed16le,
+    buffer: [0x57, 0x19],
+    expected: 25.34,
+    size: 2,
+    precision: 0.005,
+  },
+  {
+    name: "fixed32be",
+    type: fixed32be,
+    buffer: [0x00, 0xfa, 0x8c, 0xcc],
+    expected: 250.55,
+    size: 4,
+    precision: 0.005,
+  },
+  {
+    name: "fixed32le",
+    type: fixed32le,
+    buffer: [0xcc, 0x8c, 0xfa, 0x00],
+    expected: 250.55,
+    size: 4,
+    precision: 0.005,
+  },
+];
+
+const aliasCases: Array<[string, any, any]> = [
+  ["uint16", uint16, uint16be],
+  ["uint24", uint24, uint24be],
+  ["uint32", uint32, uint32be],
+  ["int16", int16, int16be],
+  ["int24", int24, int24be],
+  ["int32", int32, int32be],
+  ["float", float, floatbe],
+  ["double", double, doublebe],
+  ["fixed16", fixed16, fixed16be],
+  ["fixed32", fixed32, fixed32be],
+];
+
+describe("Number", () => {
+  test.each(aliasCases)("%s should alias the big-endian variant", (name, alias, target) => {
+    expect(alias).to.equal(target);
+  });
+
+  describe.each(integerCases)("$name", ({ type, buffer, expected, size }) => {
+    test("should decode", () => {
+      const stream = new DecodeStream(new Uint8Array(buffer));
+      expected.forEach((value) => {
+        expect(type.decode(stream)).to.equal(value);
+      });
+    });
+
+    test("should report size", () => {
+      expect(type.size()).to.equal(size);
+    });
+
+    test("should encode", () => {
+      const stream = new EncodeStream(new Uint8Array(buffer.length));
+      expected.forEach((value) => {
+        type.encode(stream, value);
+      });
+      expect(stream.buffer).to.deep.equal(new Uint8Array(buffer));
+    });
+  });
+
+  describe.each(floatCases)("$name", ({ type, buffer, expected, size, precision }) => {
+    test("should decode", () => {
+      const stream = new DecodeStream(new Uint8Array(buffer));
+      const value = type.decode(stream);
+      if (precision) {
+        expect(value).to.be.closeTo(expected, precision);
+      } else {
+        expect(value).to.equal(expected);
+      }
+    });
+
+    test("should report size", () => {
+      expect(type.size()).to.equal(size);
+    });
+
+    test("should encode", () => {
+      const stream = new EncodeStream(new Uint8Array(buffer.length));
+      type.encode(stream, expected);
+      expect(stream.buffer).to.deep.equal(new Uint8Array(buffer));
+    });
+  });
+});

package/test/optional.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "vitest";
+import { DecodeStream, EncodeStream, Optional, uint8 } from "../src/index.js";
+
+describe("Optional", () => {
+  describe("decode", () => {
+    test("should not decode when condition is falsy", () => {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, false);
+      expect(optional.decode(stream)).to.equal(undefined);
+      expect(stream.pos).to.equal(0);
+    });
+
+    test("should not decode when condition is a function and falsy", () => {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, () => false);
+      expect(optional.decode(stream)).to.equal(undefined);
+      expect(stream.pos).to.equal(0);
+    });
+
+    test("should decode when condition is omitted", () => {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8);
+      expect(optional.decode(stream)).to.equal(0);
+      expect(stream.pos).to.equal(1);
+    });
+
+    test("should decode when condition is truthy", () => {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, true);
+      expect(optional.decode(stream)).to.equal(0);
+      expect(stream.pos).to.equal(1);
+    });
+
+    test("should decode when condition is a function and truthy", () => {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, () => true);
+      expect(optional.decode(stream)).to.equal(0);
+      expect(stream.pos).to.equal(1);
+    });
+  });
+
+  describe("size", () => {
+    test("should return 0 when condition is falsy", () => {
+      const optional = new Optional(uint8, false);
+      expect(optional.size()).to.equal(0);
+    });
+
+    test("should return 0 when condition is a function and falsy", () => {
+      const optional = new Optional(uint8, () => false);
+      expect(optional.size()).to.equal(0);
+    });
+
+    test("should return given type size when condition is omitted", () => {
+      const optional = new Optional(uint8);
+      expect(optional.size()).to.equal(1);
+    });
+
+    test("should return given type size when condition is truthy", () => {
+      const optional = new Optional(uint8, true);
+      expect(optional.size()).to.equal(1);
+    });
+
+    test("should return given type size when condition is a function and truthy", () => {
+      const optional = new Optional(uint8, () => true);
+      expect(optional.size()).to.equal(1);
+    });
+  });
+
+  describe("encode", () => {
+    test("should not encode when condition is falsy", () => {
+      const optional = new Optional(uint8, false);
+      const stream = new EncodeStream(new Uint8Array(0));
+      optional.encode(stream, 128);
+      expect(stream.buffer).to.deep.equal(new Uint8Array(0));
+    });
+
+    test("should not encode when condition is a function and falsy", () => {
+      const optional = new Optional(uint8, () => false);
+      const stream = new EncodeStream(new Uint8Array(0));
+      optional.encode(stream, 128);
+      expect(stream.buffer).to.deep.equal(new Uint8Array(0));
+    });
+
+    test("should encode when condition is omitted", () => {
+      const optional = new Optional(uint8);
+      const stream = new EncodeStream(new Uint8Array(1));
+      optional.encode(stream, 128);
+      expect(stream.buffer).to.deep.equal(new Uint8Array([128]));
+    });
+
+    test("should encode when condition is truthy", () => {
+      const optional = new Optional(uint8, true);
+      const stream = new EncodeStream(new Uint8Array(1));
+      optional.encode(stream, 128);
+      expect(stream.buffer).to.deep.equal(new Uint8Array([128]));
+    });
+
+    test("should encode when condition is a function and truthy", () => {
+      const optional = new Optional(uint8, () => true);
+      const stream = new EncodeStream(new Uint8Array(1));
+      optional.encode(stream, 128);
+      expect(stream.buffer).to.deep.equal(new Uint8Array([128]));
+    });
+  });
+});