@chr33s/pdf-restructure 5.0.0 → 5.0.2

package/test/number.test.ts

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

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

package/test/pointer.test.ts

@@ -1,248 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { DecodeStream, EncodeStream, Pointer, Struct, VoidPointer, uint8 } from "../src/index.js";
-
-describe("Pointer", () => {
-  describe("decode", () => {
-    test("should handle null pointers", () => {
-      const stream = new DecodeStream(new Uint8Array([0]));
-      const pointer = new Pointer(uint8, uint8);
-      expect(pointer.decode(stream, { _startOffset: 50 })).to.equal(null);
-    });
-
-    test("should use local offsets from start of parent by default", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 53]));
-      const pointer = new Pointer(uint8, uint8);
-      expect(pointer.decode(stream, { _startOffset: 0 })).to.equal(53);
-    });
-
-    test("should support immediate offsets", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 53]));
-      const pointer = new Pointer(uint8, uint8, { type: "immediate" });
-      expect(pointer.decode(stream, {})).to.equal(53);
-    });
-
-    test("should support offsets relative to the parent", () => {
-      const stream = new DecodeStream(new Uint8Array([0, 0, 1, 53]));
-      stream.pos = 2;
-      const pointer = new Pointer(uint8, uint8, { type: "parent" });
-      expect(pointer.decode(stream, { parent: { _startOffset: 2 } })).to.equal(53);
-    });
-
-    test("should support global offsets", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 2, 4, 0, 0, 0, 53]));
-      const pointer = new Pointer(uint8, uint8, { type: "global" });
-      stream.pos = 2;
-      expect(pointer.decode(stream, { parent: { parent: { _startOffset: 2 } } })).to.equal(53);
-    });
-
-    test("should support offsets relative to a property on the parent", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 0, 0, 0, 0, 53]));
-      const pointer = new Pointer(uint8, uint8, { relativeTo: "parent.ptr" });
-      expect(pointer.decode(stream, { _startOffset: 0, parent: { ptr: 4 } })).to.equal(53);
-    });
-
-    test("should support returning pointer if there is no decode type", () => {
-      const stream = new DecodeStream(new Uint8Array([4]));
-      const pointer = new Pointer(uint8, "void");
-      expect(pointer.decode(stream, { _startOffset: 0 })).to.equal(4);
-    });
-
-    test("should support decoding pointers lazily", () => {
-      const stream = new DecodeStream(new Uint8Array([1, 53]));
-      const struct = new Struct({
-        ptr: new Pointer(uint8, uint8, { lazy: true }),
-      });
-
-      const res = struct.decode(stream);
-      const descriptor = Object.getOwnPropertyDescriptor(res, "ptr");
-      expect(typeof descriptor?.get).to.equal("function");
-      expect(descriptor?.enumerable).to.equal(true);
-      expect(res.ptr).to.equal(53);
-    });
-  });
-
-  describe("size", () => {
-    test("should add to local pointerSize", () => {
-      const pointer = new Pointer(uint8, uint8);
-      const ctx: any = { pointerSize: 0 };
-      expect(pointer.size(10, ctx)).to.equal(1);
-      expect(ctx.pointerSize).to.equal(1);
-    });
-
-    test("should add to immediate pointerSize", () => {
-      const pointer = new Pointer(uint8, uint8, { type: "immediate" });
-      const ctx: any = { pointerSize: 0 };
-      expect(pointer.size(10, ctx)).to.equal(1);
-      expect(ctx.pointerSize).to.equal(1);
-    });
-
-    test("should add to parent pointerSize", () => {
-      const pointer = new Pointer(uint8, uint8, { type: "parent" });
-      const ctx: any = { parent: { pointerSize: 0 } };
-      expect(pointer.size(10, ctx)).to.equal(1);
-      expect(ctx.parent.pointerSize).to.equal(1);
-    });
-
-    test("should add to global pointerSize", () => {
-      const pointer = new Pointer(uint8, uint8, { type: "global" });
-      const ctx: any = { parent: { parent: { parent: { pointerSize: 0 } } } };
-      expect(pointer.size(10, ctx)).to.equal(1);
-      expect(ctx.parent.parent.parent.pointerSize).to.equal(1);
-    });
-
-    test("should handle void pointers", () => {
-      const pointer = new Pointer(uint8, "void");
-      const ctx: any = { pointerSize: 0 };
-      expect(pointer.size(new VoidPointer(uint8, 50), ctx)).to.equal(1);
-      expect(ctx.pointerSize).to.equal(1);
-    });
-
-    test("should throw if no type and not a void pointer", () => {
-      const pointer = new Pointer(uint8, "void");
-      const ctx: any = { pointerSize: 0 };
-      expect(() => pointer.size(30, ctx)).to.throw();
-    });
-
-    test("should return a fixed size without a value", () => {
-      const pointer = new Pointer(uint8, uint8);
-      expect(pointer.size()).to.equal(1);
-    });
-  });
-
-  describe("encode", () => {
-    test("should handle null pointers", () => {
-      const stream = new EncodeStream(new Uint8Array(1));
-      const ptr = new Pointer(uint8, uint8);
-      const ctx: any = {
-        pointerSize: 0,
-        startOffset: 0,
-        pointerOffset: 0,
-        pointers: [],
-      };
-
-      ptr.encode(stream, null, ctx);
-      expect(ctx.pointerSize).to.equal(0);
-      expect(stream.buffer.subarray(0, stream.pos)).to.deep.equal(new Uint8Array([0]));
-    });
-
-    test("should handle local offsets", () => {
-      const stream = new EncodeStream(new Uint8Array(1));
-      const ptr = new Pointer(uint8, uint8);
-      const ctx: any = {
-        pointerSize: 0,
-        startOffset: 0,
-        pointerOffset: 1,
-        pointers: [],
-      };
-
-      ptr.encode(stream, 10, ctx);
-      expect(ctx.pointerOffset).to.equal(2);
-      expect(ctx.pointers).to.deep.equal([{ type: uint8, val: 10, parent: ctx }]);
-      expect(stream.buffer.subarray(0, stream.pos)).to.deep.equal(new Uint8Array([1]));
-    });
-
-    test("should handle immediate offsets", () => {
-      const stream = new EncodeStream(new Uint8Array(1));
-      const ptr = new Pointer(uint8, uint8, { type: "immediate" });
-      const ctx: any = {
-        pointerSize: 0,
-        startOffset: 0,
-        pointerOffset: 1,
-        pointers: [],
-      };
-
-      ptr.encode(stream, 10, ctx);
-      expect(ctx.pointerOffset).to.equal(2);
-      expect(ctx.pointers).to.deep.equal([{ type: uint8, val: 10, parent: ctx }]);
-      expect(stream.buffer.subarray(0, stream.pos)).to.deep.equal(new Uint8Array([0]));
-    });
-
-    test("should handle offsets relative to parent", () => {
-      const stream = new EncodeStream(new Uint8Array(1));
-      const ptr = new Pointer(uint8, uint8, { type: "parent" });
-      const ctx: any = {
-        parent: {
-          pointerSize: 0,
-          startOffset: 3,
-          pointerOffset: 5,
-          pointers: [],
-        },
-      };
-
-      ptr.encode(stream, 10, ctx);
-      expect(ctx.parent.pointerOffset).to.equal(6);
-      expect(ctx.parent.pointers).to.deep.equal([{ type: uint8, val: 10, parent: ctx }]);
-      expect(stream.buffer.subarray(0, stream.pos)).to.deep.equal(new Uint8Array([2]));
-    });
-
-    test("should handle global offsets", () => {
-      const stream = new EncodeStream(new Uint8Array(1));
-      const ptr = new Pointer(uint8, uint8, { type: "global" });
-      const ctx: any = {
-        parent: {
-          parent: {
-            parent: {
-              pointerSize: 0,
-              startOffset: 3,
-              pointerOffset: 5,
-              pointers: [],
-            },
-          },
-        },
-      };
-
-      ptr.encode(stream, 10, ctx);
-      expect(ctx.parent.parent.parent.pointerOffset).to.equal(6);
-      expect(ctx.parent.parent.parent.pointers).to.deep.equal([
-        { type: uint8, val: 10, parent: ctx },
-      ]);
-      expect(stream.buffer.subarray(0, stream.pos)).to.deep.equal(new Uint8Array([5]));
-    });
-
-    test("should support offsets relative to a property on the parent", () => {
-      const stream = new EncodeStream(new Uint8Array(1));
-      const ptr = new Pointer(uint8, uint8, { relativeTo: "ptr" });
-      const ctx: any = {
-        pointerSize: 0,
-        startOffset: 0,
-        pointerOffset: 10,
-        pointers: [],
-        val: { ptr: 4 },
-      };
-
-      ptr.encode(stream, 10, ctx);
-      expect(ctx.pointerOffset).to.equal(11);
-      expect(ctx.pointers).to.deep.equal([{ type: uint8, val: 10, parent: ctx }]);
-      expect(stream.buffer.subarray(0, stream.pos)).to.deep.equal(new Uint8Array([6]));
-    });
-
-    test("should support void pointers", () => {
-      const stream = new EncodeStream(new Uint8Array(1));
-      const ptr = new Pointer(uint8, "void");
-      const ctx: any = {
-        pointerSize: 0,
-        startOffset: 0,
-        pointerOffset: 1,
-        pointers: [],
-      };
-
-      ptr.encode(stream, new VoidPointer(uint8, 55), ctx);
-      expect(ctx.pointerOffset).to.equal(2);
-      expect(ctx.pointers).to.deep.equal([{ type: uint8, val: 55, parent: ctx }]);
-      expect(stream.buffer.subarray(0, stream.pos)).to.deep.equal(new Uint8Array([1]));
-    });
-
-    test("should throw if not a void pointer instance", () => {
-      const stream = new EncodeStream(new Uint8Array(10));
-      const ptr = new Pointer(uint8, "void");
-      const ctx: any = {
-        pointerSize: 0,
-        startOffset: 0,
-        pointerOffset: 1,
-        pointers: [],
-      };
-
-      expect(() => ptr.encode(stream, 44, ctx)).to.throw();
-    });
-  });
-});

package/test/reserved.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { DecodeStream, EncodeStream, Reserved, uint16, uint8 } from "../src/index.js";
-
-describe("Reserved", () => {
-  test("should have a default count of 1", () => {
-    const reserved = new Reserved(uint8);
-    expect(reserved.size()).to.equal(1);
-  });
-
-  test("should allow custom counts and types", () => {
-    const reserved = new Reserved(uint16, 10);
-    expect(reserved.size()).to.equal(20);
-  });
-
-  test("should decode", () => {
-    const stream = new DecodeStream(new Uint8Array([0, 0]));
-    const reserved = new Reserved(uint16);
-    expect(reserved.decode(stream)).to.equal(undefined);
-    expect(stream.pos).to.equal(2);
-  });
-
-  test("should encode", () => {
-    const reserved = new Reserved(uint16);
-    const stream = new EncodeStream(new Uint8Array(2));
-    reserved.encode(stream);
-    expect(stream.buffer).to.deep.equal(new Uint8Array([0, 0]));
-  });
-});