@chr33s/pdf-restructure 5.0.0

package/dist/versioned-struct.js

@@ -0,0 +1,129 @@
+import Struct from "./struct.js";
+export default class VersionedStruct extends Struct {
+    type;
+    versions;
+    constructor(type, versions = {}) {
+        super();
+        this.type = type;
+        this.versions = versions;
+    }
+    #versionGetter(parent) {
+        if (typeof this.type === "string") {
+            return this.type
+                .split(".")
+                .reduce((obj, prop) => (typeof obj !== "undefined" ? obj[prop] : undefined), parent);
+        }
+        return undefined;
+    }
+    decode(stream, parent, length = 0) {
+        const result = this._setup(stream, parent, length);
+        if (typeof this.type === "string") {
+            result.version = this.#versionGetter(parent);
+        }
+        else {
+            result.version = this.type.decode(stream);
+        }
+        if (this.versions.header) {
+            this._parseFields(stream, result, this.versions.header);
+        }
+        const fields = this.versions[result.version];
+        if (!fields) {
+            throw new Error(`Unknown version ${result.version}`);
+        }
+        if (fields instanceof VersionedStruct) {
+            return fields.decode(stream, parent);
+        }
+        this._parseFields(stream, result, fields);
+        if (this.process) {
+            this.process.call(result, stream);
+        }
+        return result;
+    }
+    size(val, parent, includePointers = true) {
+        if (!val) {
+            throw new Error("Not a fixed size");
+        }
+        if (this.preEncode) {
+            this.preEncode.call(val);
+        }
+        const ctx = {
+            parent,
+            val,
+            pointerSize: 0,
+        };
+        let total = 0;
+        if (typeof this.type !== "string") {
+            total += this.type.size(val.version, ctx);
+        }
+        if (this.versions.header) {
+            for (const [key, type] of Object.entries(this.versions.header)) {
+                if (type?.size) {
+                    total += type.size(val[key], ctx);
+                }
+            }
+        }
+        const fields = this.versions[val.version];
+        if (!fields) {
+            throw new Error(`Unknown version ${val.version}`);
+        }
+        if (fields instanceof VersionedStruct) {
+            total += fields.size(val, parent, includePointers);
+            return total;
+        }
+        for (const [key, type] of Object.entries(fields)) {
+            if (type?.size) {
+                const fieldSize = type.size(val[key], ctx);
+                total += fieldSize;
+            }
+        }
+        if (includePointers) {
+            total += ctx.pointerSize;
+        }
+        return total;
+    }
+    encode(stream, val, parent) {
+        if (this.preEncode) {
+            this.preEncode.call(val, stream);
+        }
+        const ctx = {
+            pointers: [],
+            startOffset: stream.pos,
+            pointerOffset: 0,
+            pointerSize: 0,
+            parent,
+            val,
+        };
+        const sizeWithoutPointers = this.size(val, ctx, false);
+        ctx.pointerOffset = stream.pos + sizeWithoutPointers;
+        if (typeof this.type !== "string") {
+            this.type.encode(stream, val.version);
+        }
+        if (this.versions.header) {
+            for (const [key, type] of Object.entries(this.versions.header)) {
+                if (type?.encode) {
+                    type.encode(stream, val[key], ctx);
+                }
+            }
+        }
+        const fields = this.versions[val.version];
+        if (!fields) {
+            throw new Error(`Unknown version ${val.version}`);
+        }
+        if (fields instanceof VersionedStruct) {
+            fields.encode(stream, val, parent);
+        }
+        else {
+            for (const [key, type] of Object.entries(fields)) {
+                if (type?.encode) {
+                    type.encode(stream, val[key], ctx);
+                }
+            }
+        }
+        let i = 0;
+        while (i < ctx.pointers.length) {
+            const ptr = ctx.pointers[i++];
+            ptr.type.encode(stream, ptr.val, ptr.parent);
+        }
+    }
+}
+//# sourceMappingURL=versioned-struct.js.map

package/dist/versioned-struct.js.map

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

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@chr33s/pdf-restructure",
+  "version": "5.0.0",
+  "description": "Declaratively encode and decode binary data",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "typecheck": "tsc --project tsconfig.typecheck.json"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "@vitest/coverage-v8": "4.0.15",
+    "typescript": "5.9.3",
+    "vitest": "4.0.15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chr33s/pdf.git"
+  },
+  "keywords": [
+    "binary",
+    "struct",
+    "encode",
+    "decode"
+  ],
+  "author": "Andrew Dillon <andrew.dillon.j@gmail.com>",
+  "contributors": [
+    "Devon Govett <devongovett@gmail.com> (http://badassjs.com/)"
+  ],
+  "bugs": {
+    "url": "https://github.com/chr33s/pdf/issues"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/chr33s/pdf",
+  "directories": {
+    "test": "test"
+  }
+}

package/src/array.ts

@@ -0,0 +1,113 @@
+import Base from "./base.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+import { Number as NumberT } from "./number.js";
+import { resolveLength, type LengthLike } from "./utils.js";
+
+type LengthType = "count" | "bytes";
+
+export default class ArrayT<T = unknown, TResult = T[]> extends Base<TResult> {
+  public type: any;
+  public length?: LengthLike;
+  public lengthType: LengthType;
+
+  constructor(type: any, length?: LengthLike, lengthType: LengthType = "count") {
+    super();
+    this.type = type;
+    this.length = length;
+    this.lengthType = lengthType;
+  }
+
+  decode(stream: DecodeStream, parent?: any): TResult {
+    const pos = stream.pos;
+    const result: any[] = [];
+    let ctx = parent;
+    let length: number | undefined;
+
+    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: number;
+      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 as unknown as TResult;
+  }
+
+  size(array?: T[], ctx?: any, includePointers = true): number {
+    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: EncodeStream, array: T[], parent?: any): void {
+    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);
+      }
+    }
+  }
+}

package/src/base.ts

@@ -0,0 +1,17 @@
+import DecodeStream from "./decode-stream.js";
+import EncodeStream from "./encode-stream.js";
+
+export default abstract class Base<T = unknown> {
+  fromBuffer(buffer: Uint8Array): T {
+    const stream = new DecodeStream(buffer);
+    return (this as any).decode(stream);
+  }
+
+  toBuffer(value: T): Uint8Array {
+    const size = typeof (this as any).size === "function" ? (this as any).size(value) : 0;
+    const buffer = new Uint8Array(size);
+    const stream = new EncodeStream(buffer);
+    (this as any).encode(stream, value);
+    return buffer;
+  }
+}

package/src/bitfield.ts

@@ -0,0 +1,46 @@
+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>> {
+  public type: any;
+  public flags: Array<string | null | undefined>;
+
+  constructor(type: any, flags: Array<string | null | undefined> = []) {
+    super();
+    this.type = type;
+    this.flags = flags;
+  }
+
+  decode(stream: DecodeStream): Record<string, boolean> {
+    const value = this.type.decode(stream);
+    const result: Record<string, boolean> = {};
+
+    this.flags.forEach((flag, index) => {
+      if (!flag) {
+        return;
+      }
+      result[flag] = Boolean(value & (1 << index));
+    });
+
+    return result;
+  }
+
+  size(): number {
+    return this.type.size();
+  }
+
+  encode(stream: EncodeStream, keys: Record<string, boolean>): void {
+    let value = 0;
+    this.flags.forEach((flag, index) => {
+      if (!flag) {
+        return;
+      }
+      if (keys[flag]) {
+        value |= 1 << index;
+      }
+    });
+
+    this.type.encode(stream, value);
+  }
+}

package/src/boolean.ts

@@ -0,0 +1,24 @@
+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> {
+  public type: any;
+
+  constructor(type: any) {
+    super();
+    this.type = type;
+  }
+
+  decode(stream: DecodeStream, parent?: any): boolean {
+    return Boolean(this.type.decode(stream, parent));
+  }
+
+  size(value?: any, parent?: any): number {
+    return this.type.size(value, parent);
+  }
+
+  encode(stream: EncodeStream, value: boolean, parent?: any): void {
+    this.type.encode(stream, Number(value), parent);
+  }
+}

package/src/buffer.ts

@@ -0,0 +1,40 @@
+import Base from "./base.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+import { Number as NumberT } from "./number.js";
+import { resolveLength, type LengthLike } from "./utils.js";
+
+export default class BufferT extends Base<Uint8Array> {
+  public length: LengthLike;
+
+  constructor(length: LengthLike) {
+    super();
+    this.length = length;
+  }
+
+  decode(stream: DecodeStream, parent?: any): Uint8Array {
+    const length = resolveLength(this.length, stream, parent);
+    return stream.readBuffer(length);
+  }
+
+  size(value?: Uint8Array, parent?: any): number {
+    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: EncodeStream, value: Uint8Array, _parent?: any): void {
+    if (this.length instanceof NumberT) {
+      this.length.encode(stream, value.length);
+    }
+
+    stream.writeBuffer(value);
+  }
+}

package/src/decode-stream.ts

@@ -0,0 +1,97 @@
+// Node back-compat.
+const ENCODING_MAPPING: Record<string, string> = {
+  utf16le: "utf-16le",
+  ucs2: "utf-16le",
+  utf16be: "utf-16be",
+};
+
+export default class DecodeStream {
+  public static readonly TYPES = {
+    UInt8: 1,
+    UInt16: 2,
+    UInt24: 3,
+    UInt32: 4,
+    Int8: 1,
+    Int16: 2,
+    Int24: 3,
+    Int32: 4,
+    Float: 4,
+    Double: 8,
+  } as const;
+
+  public pos = 0;
+  public length: number;
+  public buffer: Uint8Array;
+  public view: DataView;
+  [key: string]: any;
+
+  constructor(buffer: Uint8Array | Buffer) {
+    this.buffer = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    this.length = this.buffer.length;
+  }
+
+  readString(length: number, encoding: string = "ascii"): string | Uint8Array {
+    encoding = ENCODING_MAPPING[encoding] || encoding;
+
+    const buf = this.readBuffer(length);
+    try {
+      const decoder = new TextDecoder(encoding);
+      return decoder.decode(buf);
+    } catch {
+      return buf;
+    }
+  }
+
+  readBuffer(length: number): Uint8Array {
+    return this.buffer.slice(this.pos, (this.pos += length));
+  }
+
+  readUInt24BE(): number {
+    return (this.readUInt16BE() << 8) + this.readUInt8();
+  }
+
+  readUInt24LE(): number {
+    return this.readUInt16LE() + (this.readUInt8() << 16);
+  }
+
+  readInt24BE(): number {
+    return (this.readInt16BE() << 8) + this.readUInt8();
+  }
+
+  readInt24LE(): number {
+    return this.readUInt16LE() + (this.readInt8() << 16);
+  }
+}
+
+// Generate read methods from DataView prototype
+for (const key of Object.getOwnPropertyNames(DataView.prototype)) {
+  if (key.slice(0, 3) === "get") {
+    let type = key.slice(3).replace("Ui", "UI");
+    if (type === "Float32") {
+      type = "Float";
+    } else if (type === "Float64") {
+      type = "Double";
+    }
+    const bytes = DecodeStream.TYPES[type as keyof typeof DecodeStream.TYPES];
+    if (!bytes) {
+      continue;
+    }
+
+    (DecodeStream.prototype as any)["read" + type + (bytes === 1 ? "" : "BE")] = function (
+      this: DecodeStream,
+    ) {
+      const ret = (this.view as any)[key](this.pos, false);
+      this.pos += bytes;
+      return ret;
+    };
+
+    if (bytes !== 1) {
+      (DecodeStream.prototype as any)["read" + type + "LE"] = function (this: DecodeStream) {
+        const ret = (this.view as any)[key](this.pos, true);
+        this.pos += bytes;
+        return ret;
+      };
+    }
+  }
+}

package/src/encode-stream.ts

@@ -0,0 +1,161 @@
+import DecodeStream from "./decode-stream.js";
+
+const textEncoder = new TextEncoder();
+const isBigEndian = new Uint8Array(new Uint16Array([0x1234]).buffer)[0] === 0x12;
+
+export default class EncodeStream {
+  public buffer: Uint8Array;
+  public view: DataView;
+  public pos = 0;
+  [key: string]: any;
+
+  constructor(buffer: Uint8Array) {
+    this.buffer = buffer;
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+
+  /**
+   * Ensure the buffer has enough space for the given number of bytes.
+   * If not, grow the buffer.
+   */
+  ensureCapacity(bytes: number): void {
+    const needed = this.pos + bytes;
+    if (needed <= this.buffer.length) {
+      return;
+    }
+    // Grow by at least 2x or to the needed size, whichever is larger
+    const newSize = Math.max(this.buffer.length * 2, needed);
+    const newBuffer = new Uint8Array(newSize);
+    newBuffer.set(this.buffer);
+    this.buffer = newBuffer;
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+
+  writeBuffer(buffer: Uint8Array): void {
+    this.ensureCapacity(buffer.length);
+    this.buffer.set(buffer, this.pos);
+    this.pos += buffer.length;
+  }
+
+  writeString(string: string, encoding: string = "ascii"): void {
+    let buf: Uint8Array;
+    switch (encoding) {
+      case "utf16le":
+      case "utf16-le":
+      case "ucs2": // node treats this the same as utf16.
+        buf = stringToUtf16(string, isBigEndian);
+        break;
+
+      case "utf16be":
+      case "utf16-be":
+        buf = stringToUtf16(string, !isBigEndian);
+        break;
+
+      case "utf8":
+        buf = textEncoder.encode(string);
+        break;
+
+      case "ascii":
+        buf = stringToAscii(string);
+        break;
+
+      default:
+        throw new Error(`Unsupported encoding: ${encoding}`);
+    }
+
+    this.writeBuffer(buf);
+  }
+
+  writeUInt24BE(val: number): void {
+    this.ensureCapacity(3);
+    this.buffer[this.pos++] = (val >>> 16) & 0xff;
+    this.buffer[this.pos++] = (val >>> 8) & 0xff;
+    this.buffer[this.pos++] = val & 0xff;
+  }
+
+  writeUInt24LE(val: number): void {
+    this.ensureCapacity(3);
+    this.buffer[this.pos++] = val & 0xff;
+    this.buffer[this.pos++] = (val >>> 8) & 0xff;
+    this.buffer[this.pos++] = (val >>> 16) & 0xff;
+  }
+
+  writeInt24BE(val: number): void {
+    if (val >= 0) {
+      this.writeUInt24BE(val);
+    } else {
+      this.writeUInt24BE(val + 0xffffff + 1);
+    }
+  }
+
+  writeInt24LE(val: number): void {
+    if (val >= 0) {
+      this.writeUInt24LE(val);
+    } else {
+      this.writeUInt24LE(val + 0xffffff + 1);
+    }
+  }
+
+  fill(val: number, length: number): void {
+    this.ensureCapacity(length);
+    this.buffer.fill(val, this.pos, this.pos + length);
+    this.pos += length;
+  }
+}
+
+function stringToUtf16(string: string, swap: boolean): Uint8Array {
+  const buf = new Uint16Array(string.length);
+  for (let i = 0; i < string.length; i++) {
+    let code = string.charCodeAt(i);
+    if (swap) {
+      code = (code >> 8) | ((code & 0xff) << 8);
+    }
+    buf[i] = code;
+  }
+  return new Uint8Array(buf.buffer);
+}
+
+function stringToAscii(string: string): Uint8Array {
+  const buf = new Uint8Array(string.length);
+  for (let i = 0; i < string.length; i++) {
+    // Match node.js behavior - encoding allows 8-bit rather than 7-bit.
+    buf[i] = string.charCodeAt(i);
+  }
+  return buf;
+}
+
+// Generate write methods from DataView prototype
+for (const key of Object.getOwnPropertyNames(DataView.prototype)) {
+  if (key.slice(0, 3) === "set") {
+    let type = key.slice(3).replace("Ui", "UI");
+    if (type === "Float32") {
+      type = "Float";
+    } else if (type === "Float64") {
+      type = "Double";
+    }
+    const bytes = DecodeStream.TYPES[type as keyof typeof DecodeStream.TYPES];
+    if (!bytes) {
+      continue;
+    }
+
+    (EncodeStream.prototype as any)["write" + type + (bytes === 1 ? "" : "BE")] = function (
+      this: EncodeStream,
+      value: number,
+    ) {
+      this.ensureCapacity(bytes);
+      (this.view as any)[key](this.pos, value, false);
+      this.pos += bytes;
+    };
+
+    if (bytes !== 1) {
+      (EncodeStream.prototype as any)["write" + type + "LE"] = function (
+        this: EncodeStream,
+        value: number,
+      ) {
+        this.ensureCapacity(bytes);
+        (this.view as any)[key](this.pos, value, true);
+        this.pos += bytes;
+      };
+    }
+  }
+}