@chr33s/pdf-restructure 5.0.0

package/src/enum.ts

@@ -0,0 +1,32 @@
+import Base from "./base.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+
+export default class Enum<T = unknown> extends Base<T> {
+  public type: any;
+  public options: T[];
+
+  constructor(type: any, options: T[] = []) {
+    super();
+    this.type = type;
+    this.options = options;
+  }
+
+  decode(stream: DecodeStream): T {
+    const index = this.type.decode(stream);
+    return this.options[index] ?? index;
+  }
+
+  size(): number {
+    return this.type.size();
+  }
+
+  encode(stream: EncodeStream, value: T): void {
+    const index = this.options.indexOf(value);
+    if (index === -1) {
+      throw new Error(`Unknown option in enum: ${String(value)}`);
+    }
+
+    this.type.encode(stream, index);
+  }
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+export { default as Array } from "./array.js";
+export { default as Base } from "./base.js";
+export { default as Bitfield } from "./bitfield.js";
+export { default as Boolean } from "./boolean.js";
+export { default as Buffer } from "./buffer.js";
+export { default as DecodeStream } from "./decode-stream.js";
+export { default as EncodeStream } from "./encode-stream.js";
+export { default as Enum } from "./enum.js";
+export { default as LazyArray } from "./lazy-array.js";
+export * from "./number.js";
+export { default as Optional } from "./optional.js";
+export * from "./pointer.js";
+export { default as Reserved } from "./reserved.js";
+export { default as String } from "./string.js";
+export { default as Struct } from "./struct.js";
+export * from "./utils.js";
+export { default as VersionedStruct } from "./versioned-struct.js";

package/src/lazy-array.ts

@@ -0,0 +1,91 @@
+import ArrayT from "./array.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+import { Number as NumberT } from "./number.js";
+import { resolveLength } from "./utils.js";
+
+// Node.js inspect symbol for custom formatting
+const inspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+
+export class LazyArray<T = unknown> {
+  #base: number;
+  #items: Array<T | undefined> = [];
+
+  public type: any;
+  public length: number;
+  public stream: DecodeStream;
+  public ctx: any;
+
+  constructor(type: any, length: number, stream: DecodeStream, ctx: any) {
+    this.type = type;
+    this.length = length;
+    this.stream = stream;
+    this.ctx = ctx;
+    this.#base = stream.pos;
+  }
+
+  get(index: number): T | undefined {
+    if (index < 0 || index >= this.length) {
+      return undefined;
+    }
+
+    if (typeof this.#items[index] === "undefined") {
+      const pos = this.stream.pos;
+      this.stream.pos = this.#base + this.type.size(null, this.ctx) * index;
+      this.#items[index] = this.type.decode(this.stream, this.ctx);
+      this.stream.pos = pos;
+    }
+
+    return this.#items[index];
+  }
+
+  toArray(): T[] {
+    const values: T[] = [];
+    for (let i = 0; i < this.length; i += 1) {
+      const value = this.get(i);
+      if (typeof value !== "undefined") {
+        values.push(value);
+      }
+    }
+    return values;
+  }
+
+  inspect(): string {
+    return JSON.stringify(this.toArray());
+  }
+
+  [inspectSymbol](): string {
+    return JSON.stringify(this.toArray());
+  }
+}
+
+export default class LazyArrayT<T = unknown> extends ArrayT<T, LazyArray<T>> {
+  decode(stream: DecodeStream, parent?: any): LazyArray<T> {
+    const pos = stream.pos;
+    const length = resolveLength(this.length, stream, parent);
+    let ctx = parent;
+
+    if (this.length instanceof NumberT) {
+      ctx = {
+        parent,
+        _startOffset: pos,
+        _currentOffset: 0,
+        _length: length,
+      };
+    }
+
+    const result = new LazyArray<T>(this.type, length, stream, ctx);
+    stream.pos += length * this.type.size(null, ctx);
+    return result;
+  }
+
+  size(value?: LazyArray<T> | T[], ctx?: any): number {
+    const resolved = value instanceof LazyArray ? value.toArray() : value;
+    return super.size(resolved as T[] | undefined, ctx);
+  }
+
+  encode(stream: EncodeStream, value: LazyArray<T> | T[], ctx?: any): void {
+    const resolved = value instanceof LazyArray ? value.toArray() : value;
+    super.encode(stream, resolved as T[], ctx);
+  }
+}

package/src/number.ts

@@ -0,0 +1,88 @@
+import Base from "./base.js";
+import DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+
+export class NumberT extends Base<number> {
+  #fn: string;
+  public type: string;
+  public endian: "BE" | "LE";
+
+  constructor(type: string, endian: "BE" | "LE" = "BE") {
+    super();
+    this.type = type;
+    this.endian = endian;
+    this.#fn = type;
+    if (this.type[this.type.length - 1] !== "8") {
+      this.#fn += this.endian;
+    }
+  }
+
+  size(): number {
+    const size = DecodeStream.TYPES[this.type as keyof typeof DecodeStream.TYPES];
+    if (!size) {
+      throw new Error(`Unknown number type: ${this.type}`);
+    }
+    return size;
+  }
+
+  decode(stream: DecodeStream): number {
+    return (stream as any)[`read${this.#fn}`]();
+  }
+
+  encode(stream: EncodeStream, value: number): void {
+    (stream as any)[`write${this.#fn}`](value);
+  }
+}
+
+export const Number = NumberT;
+
+export const uint8 = new NumberT("UInt8");
+export const uint16be = new NumberT("UInt16", "BE");
+export const uint16le = new NumberT("UInt16", "LE");
+export const uint16 = uint16be;
+export const uint24be = new NumberT("UInt24", "BE");
+export const uint24le = new NumberT("UInt24", "LE");
+export const uint24 = uint24be;
+export const uint32be = new NumberT("UInt32", "BE");
+export const uint32le = new NumberT("UInt32", "LE");
+export const uint32 = uint32be;
+export const int8 = new NumberT("Int8");
+export const int16be = new NumberT("Int16", "BE");
+export const int16le = new NumberT("Int16", "LE");
+export const int16 = int16be;
+export const int24be = new NumberT("Int24", "BE");
+export const int24le = new NumberT("Int24", "LE");
+export const int24 = int24be;
+export const int32be = new NumberT("Int32", "BE");
+export const int32le = new NumberT("Int32", "LE");
+export const int32 = int32be;
+export const floatbe = new NumberT("Float", "BE");
+export const floatle = new NumberT("Float", "LE");
+export const float = floatbe;
+export const doublebe = new NumberT("Double", "BE");
+export const doublele = new NumberT("Double", "LE");
+export const double = doublebe;
+
+export class Fixed extends NumberT {
+  readonly #point: number;
+
+  constructor(size: number, endian: "BE" | "LE", fracBits = size >> 1) {
+    super(`Int${size}`, endian);
+    this.#point = 1 << fracBits;
+  }
+
+  decode(stream: DecodeStream): number {
+    return super.decode(stream) / this.#point;
+  }
+
+  encode(stream: EncodeStream, value: number): void {
+    super.encode(stream, (value * this.#point) | 0);
+  }
+}
+
+export const fixed16be = new Fixed(16, "BE");
+export const fixed16le = new Fixed(16, "LE");
+export const fixed16 = fixed16be;
+export const fixed32be = new Fixed(32, "BE");
+export const fixed32le = new Fixed(32, "LE");
+export const fixed32 = fixed32be;

package/src/optional.ts

@@ -0,0 +1,46 @@
+import Base from "./base.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+
+type Condition = boolean | ((this: any, parent?: any) => boolean);
+
+export default class Optional<T = unknown> extends Base<T | undefined> {
+  public type: any;
+  public condition: Condition;
+
+  constructor(type: any, condition: Condition = true) {
+    super();
+    this.type = type;
+    this.condition = condition;
+  }
+
+  #evaluateCondition(parent?: any): boolean {
+    if (typeof this.condition === "function") {
+      return this.condition.call(parent, parent);
+    }
+
+    return this.condition;
+  }
+
+  decode(stream: DecodeStream, parent?: any): T | undefined {
+    if (this.#evaluateCondition(parent)) {
+      return this.type.decode(stream, parent);
+    }
+
+    return undefined;
+  }
+
+  size(value?: T, parent?: any): number {
+    if (this.#evaluateCondition(parent)) {
+      return this.type.size(value, parent);
+    }
+
+    return 0;
+  }
+
+  encode(stream: EncodeStream, value: T, parent?: any): void {
+    if (this.#evaluateCondition(parent)) {
+      this.type.encode(stream, value, parent);
+    }
+  }
+}

package/src/pointer.ts

@@ -0,0 +1,204 @@
+import Base from "./base.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+import { PropertyDescriptor } from "./utils.js";
+
+export type PointerType = "local" | "immediate" | "parent" | "global";
+
+export interface PointerOptions {
+  type?: PointerType;
+  allowNull?: boolean;
+  nullValue?: number;
+  relativeTo?: string | ((ctx: any) => number);
+  lazy?: boolean;
+}
+
+export class Pointer extends Base<any> {
+  public options: Required<Omit<PointerOptions, "relativeTo">> & {
+    relativeTo?: string | ((ctx: any) => number);
+  };
+  public type: any;
+  public offsetType: any;
+
+  constructor(offsetType: any, type: any, options: PointerOptions = {}) {
+    super();
+    this.offsetType = offsetType;
+    this.type = type === "void" ? null : type;
+    this.options = {
+      type: "local",
+      allowNull: true,
+      nullValue: 0,
+      lazy: false,
+      ...options,
+    };
+  }
+
+  #relativeToGetter(ctx: any): number {
+    const { relativeTo } = this.options;
+    if (!relativeTo) {
+      return 0;
+    }
+
+    if (typeof relativeTo === "function") {
+      return relativeTo(ctx) ?? 0;
+    }
+
+    return relativeTo.split(".").reduce((obj: any, prop: string) => obj?.[prop], ctx) ?? 0;
+  }
+
+  decode(stream: DecodeStream, ctx: any): any {
+    const offset = this.offsetType.decode(stream, ctx);
+
+    if (offset === this.options.nullValue && this.options.allowNull) {
+      return null;
+    }
+
+    let relative = 0;
+
+    switch (this.options.type) {
+      case "local":
+        relative = ctx?._startOffset ?? 0;
+        break;
+      case "immediate":
+        relative = stream.pos - this.offsetType.size();
+        break;
+      case "parent":
+        relative = ctx?.parent?._startOffset ?? 0;
+        break;
+      default: {
+        let current = ctx;
+        while (current?.parent) {
+          current = current.parent;
+        }
+        relative = current?._startOffset ?? 0;
+      }
+    }
+
+    if (this.options.relativeTo) {
+      relative += this.#relativeToGetter(ctx);
+    }
+
+    const ptr = offset + relative;
+
+    if (this.type) {
+      let value: any;
+      let decoded = false;
+      const decodeValue = () => {
+        if (decoded) {
+          return value;
+        }
+        const pos = stream.pos;
+        stream.pos = ptr;
+        value = this.type.decode(stream, ctx);
+        stream.pos = pos;
+        decoded = true;
+        return value;
+      };
+
+      if (this.options.lazy) {
+        return new PropertyDescriptor({ get: decodeValue });
+      }
+
+      return decodeValue();
+    }
+
+    return ptr;
+  }
+
+  size(val?: any, ctx?: any): number {
+    const parent = ctx;
+
+    if (ctx) {
+      switch (this.options.type) {
+        case "local":
+        case "immediate":
+          break;
+        case "parent":
+          ctx = ctx.parent;
+          break;
+        default:
+          while (ctx.parent) {
+            ctx = ctx.parent;
+          }
+      }
+    }
+
+    let type = this.type;
+    if (!type) {
+      if (!(val instanceof VoidPointer)) {
+        throw new Error("Must be a VoidPointer");
+      }
+      type = val.type;
+      val = val.value;
+    }
+
+    if (val != null && ctx) {
+      ctx.pointerSize += type.size(val, parent);
+    }
+
+    return this.offsetType.size();
+  }
+
+  encode(stream: EncodeStream, val: any, ctx: any): void {
+    const parent = ctx;
+
+    if (val == null) {
+      this.offsetType.encode(stream, this.options.nullValue);
+      return;
+    }
+
+    let relative: number;
+
+    switch (this.options.type) {
+      case "local":
+        relative = ctx.startOffset;
+        break;
+      case "immediate":
+        relative = stream.pos + this.offsetType.size(val, parent);
+        break;
+      case "parent":
+        ctx = ctx.parent;
+        relative = ctx.startOffset;
+        break;
+      default:
+        relative = 0;
+        while (ctx.parent) {
+          ctx = ctx.parent;
+        }
+    }
+
+    if (this.options.relativeTo) {
+      const target = parent?.val ?? parent;
+      relative += this.#relativeToGetter(target);
+    }
+
+    this.offsetType.encode(stream, ctx.pointerOffset - relative);
+
+    let type = this.type;
+    if (!type) {
+      if (!(val instanceof VoidPointer)) {
+        throw new Error("Must be a VoidPointer");
+      }
+      type = val.type;
+      val = val.value;
+    }
+
+    ctx.pointers.push({
+      type,
+      val,
+      parent,
+    });
+
+    ctx.pointerOffset += type.size(val, parent);
+  }
+}
+
+export class VoidPointer {
+  public type: any;
+  public value: any;
+
+  constructor(type: any, value: any) {
+    this.type = type;
+    this.value = value;
+  }
+}

package/src/reserved.ts

@@ -0,0 +1,29 @@
+import Base from "./base.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+import { resolveLength, type LengthLike } from "./utils.js";
+
+export default class Reserved extends Base<void> {
+  public type: any;
+  public count: LengthLike | number;
+
+  constructor(type: any, count: LengthLike | number = 1) {
+    super();
+    this.type = type;
+    this.count = count;
+  }
+
+  decode(stream: DecodeStream, parent?: any): undefined {
+    stream.pos += this.size(undefined, parent);
+    return undefined;
+  }
+
+  size(_data?: any, parent?: any): number {
+    const count = resolveLength(this.count as LengthLike, undefined, parent);
+    return this.type.size() * count;
+  }
+
+  encode(stream: EncodeStream, _val?: any, parent?: any): void {
+    stream.fill(0, this.size(undefined, parent));
+  }
+}

package/src/string.ts

@@ -0,0 +1,154 @@
+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 EncodingResolver = string | ((this: any, parent?: any) => string | undefined);
+
+const ENCODING_ALIASES: Record<string, string> = {
+  "utf-8": "utf8",
+  utf8: "utf8",
+  ascii: "ascii",
+  utf16: "utf16le",
+  "utf-16": "utf16le",
+  utf16le: "utf16le",
+  "utf-16le": "utf16le",
+  "utf16-le": "utf16le",
+  "utf-16-le": "utf16le",
+  utf16be: "utf16be",
+  "utf-16be": "utf16be",
+  "utf16-be": "utf16be",
+  "utf-16-be": "utf16be",
+  ucs2: "ucs2",
+};
+
+function normalizeEncoding(encoding: string | undefined): string {
+  if (!encoding) {
+    return "ascii";
+  }
+  const key = encoding.toLowerCase();
+  return ENCODING_ALIASES[key] ?? key;
+}
+
+function resolveEncodingValue(
+  resolver: EncodingResolver,
+  parent?: any,
+  useParentVal = false,
+): string {
+  if (typeof resolver === "function") {
+    const ctx = useParentVal ? (parent?.val ?? parent) : parent;
+    return normalizeEncoding(resolver.call(ctx, ctx));
+  }
+
+  return normalizeEncoding(resolver);
+}
+
+function encodingWidth(encoding: string): number {
+  switch (encoding) {
+    case "ascii":
+    case "utf8":
+      return 1;
+    case "utf16le":
+    case "utf16be":
+    case "ucs2":
+      return 2;
+    default:
+      return 1;
+  }
+}
+
+const textEncoder = new TextEncoder();
+
+function byteLength(string: string, encoding: string): number {
+  switch (encoding) {
+    case "utf8":
+      return textEncoder.encode(string).length;
+    case "utf16le":
+    case "utf16be":
+    case "ucs2":
+      return string.length * 2;
+    case "ascii":
+    default:
+      return string.length;
+  }
+}
+
+export default class StringT extends Base<string | Uint8Array> {
+  public length?: LengthLike;
+  public encoding: EncodingResolver;
+
+  constructor(length?: LengthLike, encoding: EncodingResolver = "ascii") {
+    super();
+    this.length = length;
+    this.encoding = encoding;
+  }
+
+  decode(stream: DecodeStream, parent?: any): string | Uint8Array {
+    const encoding = resolveEncodingValue(this.encoding, parent);
+    const width = encodingWidth(encoding);
+
+    let length: number;
+
+    if (typeof this.length !== "undefined") {
+      length = resolveLength(this.length, stream, parent);
+    } else {
+      const { buffer } = stream;
+      let pos = stream.pos;
+      const limit = stream.length;
+      const maxPos = Math.max(limit - width + 1, stream.pos);
+
+      while (pos < maxPos && (buffer[pos] !== 0x00 || (width === 2 && buffer[pos + 1] !== 0x00))) {
+        pos += width;
+      }
+
+      length = Math.max(pos - stream.pos, 0);
+    }
+
+    const value = stream.readString(length, encoding);
+
+    if (typeof this.length === "undefined" && stream.pos < stream.length) {
+      stream.pos += width;
+    }
+
+    return value;
+  }
+
+  size(value?: string, parent?: any): number {
+    if (value == null) {
+      return resolveLength(this.length, undefined, parent);
+    }
+
+    const encoding = resolveEncodingValue(this.encoding, parent, true);
+    let size = byteLength(value, encoding);
+
+    if (this.length instanceof NumberT) {
+      size += this.length.size();
+    }
+
+    if (typeof this.length === "undefined") {
+      size += encodingWidth(encoding);
+    }
+
+    return size;
+  }
+
+  encode(stream: EncodeStream, value: string, parent?: any): void {
+    const encoding = resolveEncodingValue(this.encoding, parent, true);
+    const width = encodingWidth(encoding);
+
+    if (this.length instanceof NumberT) {
+      this.length.encode(stream, byteLength(value, encoding));
+    }
+
+    stream.writeString(value, encoding);
+
+    if (typeof this.length === "undefined") {
+      if (width === 2) {
+        stream.writeUInt16LE(0x0000);
+      } else {
+        stream.writeUInt8(0x00);
+      }
+    }
+  }
+}