pagyra-js 0.0.1

package/src/pdf/font/ttf-table-parser.ts

@@ -0,0 +1,132 @@
+/**
+ * TtfTableParser
+ * Small utility to read table directory and provide safe big-endian reads.
+ *
+ * This file was extracted from ttf-lite.ts as part of SRP refactor. Keep the
+ * implementation minimal and focused on DataView/table-directory logic.
+ */
+
+import { log } from "../../logging/debug.js";
+
+export interface TableDirectoryEntry {
+  tag: number;
+  checksum: number;
+  offset: number;
+  length: number;
+}
+
+export class TtfTableParser {
+  private readonly dataView: DataView;
+  private readonly tableDirectory = new Map<number, TableDirectoryEntry>();
+
+  constructor(buffer: ArrayBuffer) {
+    this.dataView = new DataView(buffer);
+    this.parseTableDirectory();
+  }
+
+  private parseTableDirectory(): void {
+    // Validate minimal header present
+    if (this.dataView.byteLength < 12) {
+      throw new Error("Truncated TTF header");
+    }
+
+    const numTables = this.dataView.getUint16(4, false); // big-endian
+    const tableDirOffset = 12;
+    const requiredDirBytes = tableDirOffset + numTables * 16;
+    if (requiredDirBytes > this.dataView.byteLength) {
+      throw new Error("Truncated table directory");
+    }
+
+    for (let i = 0; i < numTables; i++) {
+      const offset = tableDirOffset + i * 16;
+      const tag = this.dataView.getUint32(offset, false);
+      const checksum = this.dataView.getUint32(offset + 4, false);
+      const tableOffset = this.dataView.getUint32(offset + 8, false);
+      const length = this.dataView.getUint32(offset + 12, false);
+
+      // CAVEAT FIX: Interception point for problematic tables
+      const tagString = String.fromCharCode(
+        (tag >> 24) & 0xFF,
+        (tag >> 16) & 0xFF,
+        (tag >> 8) & 0xFF,
+        tag & 0xFF
+      );
+
+      // CAVEAT SPECIFIC FIX: Force skip ONLY the exact problematic table
+      if (tagString === 'gloc') {
+        log('font', 'warn', `🚫 CAVEAT TTF PARSER: FORCE SKIPPING problematic table 'gloc' (0x${tag.toString(16)})`);
+        continue;
+      }
+
+      // Essential TTF tables that MUST NOT be filtered out
+      const essentialTables = ['cmap', 'head', 'hhea', 'hmtx', 'maxp', 'name', 'OS/2', 'post'];
+
+      // Bounds validation - allow graceful skip for non-essential tables
+      if (tableOffset + length > this.dataView.byteLength) {
+        if (essentialTables.includes(tagString)) {
+          log('font', 'warn', `WOFF2 TTF: ESSENTIAL table ${tagString} has bounds issues - attempting to proceed with clamped length`);
+          // For essential tables, clamp the length to fit within file bounds
+          const clampedLength = Math.min(length, this.dataView.byteLength - tableOffset);
+          if (clampedLength > 0) {
+            this.tableDirectory.set(tag, {
+              tag,
+              checksum,
+              offset: tableOffset,
+              length: clampedLength
+            });
+            log('font', 'debug', `✅ CAVEAT TTF PARSER: KEPT essential table ${tagString} with clamped length ${clampedLength}`);
+          } else {
+            log('font', 'warn', `WOFF2 TTF: Essential table ${tagString} completely out of bounds - skipping`);
+          }
+        } else {
+          log('font', 'warn', `WOFF2 TTF: Skipping optional table ${tagString} due to bounds issues`);
+          continue;
+        }
+      } else {
+        this.tableDirectory.set(tag, {
+          tag,
+          checksum,
+          offset: tableOffset,
+          length
+        });
+      }
+    }
+  }
+
+  getTable(tag: number): DataView | null {
+    const entry = this.tableDirectory.get(tag);
+    if (!entry) return null;
+
+    // Extra guard for safety before creating a DataView
+    if (entry.offset + entry.length > this.dataView.byteLength) {
+      throw new Error(`Invalid table entry for tag 0x${tag.toString(16)}`);
+    }
+
+    return new DataView(this.dataView.buffer, entry.offset, entry.length);
+  }
+
+  getUint16(table: DataView, offset: number): number {
+    if (offset + 2 > table.byteLength) throw new Error("Read beyond table bounds (getUint16)");
+    return table.getUint16(offset, false); // big-endian
+  }
+
+  getInt16(table: DataView, offset: number): number {
+    if (offset + 2 > table.byteLength) throw new Error("Read beyond table bounds (getInt16)");
+    return table.getInt16(offset, false); // big-endian
+  }
+
+  getInt8(table: DataView, offset: number): number {
+    if (offset + 1 > table.byteLength) throw new Error("Read beyond table bounds (getInt8)");
+    return table.getInt8(offset);
+  }
+
+  getUint8(table: DataView, offset: number): number {
+    if (offset + 1 > table.byteLength) throw new Error("Read beyond table bounds (getUint8)");
+    return table.getUint8(offset);
+  }
+
+  getUint32(table: DataView, offset: number): number {
+    if (offset + 4 > table.byteLength) throw new Error("Read beyond table bounds (getUint32)");
+    return table.getUint32(offset, false); // big-endian
+  }
+}

package/src/pdf/font/ttf-table-provider.ts

@@ -0,0 +1,61 @@
+/**
+ * TrueType table provider interfaces.
+ * 
+ * These interfaces are segregated following the Interface Segregation Principle (ISP).
+ * Clients can depend only on the interfaces they actually need.
+ */
+
+/**
+ * Provides access to TrueType font tables.
+ */
+export interface TableProvider {
+    /**
+     * Retrieves a font table by its 4-byte tag.
+     * @param tag - Table tag as a 32-bit integer (e.g., 0x676c7966 for 'glyf')
+     * @returns DataView of the table data, or null if table doesn't exist
+     */
+    getTable(tag: number): DataView | null;
+}
+
+/**
+ * Provides methods for reading binary data from DataViews.
+ * Abstracts the byte-order and offset calculations.
+ */
+export interface DataViewReader {
+    getUint16(view: DataView, offset: number): number;
+    getUint32(view: DataView, offset: number): number;
+    getInt16(view: DataView, offset: number): number;
+    getInt8(view: DataView, offset: number): number;
+    getUint8(view: DataView, offset: number): number;
+}
+
+/**
+ * Combined interface for backward compatibility.
+ * Provides both table access and binary reading capabilities.
+ */
+export interface GlyphTableProvider extends TableProvider, DataViewReader { }
+
+/**
+ * Default implementation of DataViewReader using big-endian byte order (TrueType standard).
+ */
+export class DefaultDataViewReader implements DataViewReader {
+    getUint16(view: DataView, offset: number): number {
+        return view.getUint16(offset, false);
+    }
+
+    getUint32(view: DataView, offset: number): number {
+        return view.getUint32(offset, false);
+    }
+
+    getInt16(view: DataView, offset: number): number {
+        return view.getInt16(offset, false);
+    }
+
+    getInt8(view: DataView, offset: number): number {
+        return view.getInt8(offset);
+    }
+
+    getUint8(view: DataView, offset: number): number {
+        return view.getUint8(offset);
+    }
+}

package/src/pdf/font/widths.ts

@@ -0,0 +1,79 @@
+import type { TtfFontMetrics } from "../../types/fonts.js";
+
+/**
+ * Compute DW (default width) and compressed W array from glyph metrics.
+ * Shared utility used by font embedding and tests.
+ */
+export function computeWidths(metrics: TtfFontMetrics): { DW: number; W: (number | number[])[] } {
+  const count = metrics.glyphMetrics.size;
+  const widths: number[] = new Array(count).fill(0);
+  for (const [gid, gm] of metrics.glyphMetrics) {
+    widths[gid] = Math.round((gm.advanceWidth / metrics.metrics.unitsPerEm) * 1000);
+  }
+
+  const computeDW = (arr: number[]) => {
+    const freq = new Map<number, number>();
+    for (const v of arr) {
+      // Skip zero widths; a DW of 0 breaks Identity-H rendering in some viewers.
+      if (v === 0) continue;
+      freq.set(v, (freq.get(v) ?? 0) + 1);
+    }
+    // Fallback to 1000 if we only saw zeros.
+    if (freq.size === 0) {
+      return 1000;
+    }
+    let best = 1000;
+    let bestCount = -1;
+    for (const [v, c] of freq.entries()) {
+      if (c > bestCount || (c === bestCount && v < best)) {
+        best = v;
+        bestCount = c;
+      }
+    }
+    return best;
+  };
+
+  const DW = computeDW(widths);
+
+  // Compress widths into W entries using ranges for repeating values and arrays for heterogenous runs
+  // The PDF spec requires a flat array of mixed types:
+  // c [w1 w2 ... wn]
+  // c_first c_last w
+  const result: (number | number[])[] = [];
+  let i = 0;
+  while (i < count) {
+    // skip DW values
+    if (widths[i] === DW) {
+      i++;
+      continue;
+    }
+
+    // try find long run of identical width (use range if length >= 4)
+    const start = i;
+    const val = widths[i];
+    let j = i + 1;
+    while (j < count && widths[j] === val) j++;
+    const runLen = j - start;
+    if (runLen >= 4) {
+      // c_first c_last w
+      result.push(start);
+      result.push(j - 1);
+      result.push(val);
+      i = j;
+      continue;
+    }
+
+    // otherwise build a heterogenous list until we hit DW or reach a reasonable chunk (32)
+    const listStart = i;
+    const list: number[] = [];
+    while (i < count && widths[i] !== DW && list.length < 32) {
+      list.push(widths[i]);
+      i++;
+    }
+    // c [w1 ... wn]
+    result.push(listStart);
+    result.push(list);
+  }
+
+  return { DW, W: result };
+}

package/src/pdf/font-subset/font-registry.ts

@@ -0,0 +1,127 @@
+import type { UnifiedFont } from "../../fonts/types.js";
+import type { GlyphRun } from "../../layout/text-run.js";
+import { createPdfFontSubset, type PdfFontSubset } from "../font/font-subset.js";
+
+/**
+ * Combines a PDF font subset with its source UnifiedFont.
+ */
+export interface PdfFontHandle {
+    subset: PdfFontSubset;
+    unifiedFont: UnifiedFont;
+}
+
+/**
+ * Manages font subsets for PDF generation.
+ * Collects glyph usage across the document and creates font subsets on demand.
+ */
+export class PdfFontRegistry {
+    // Map from font key to set of used glyph IDs
+    private readonly glyphUsage = new Map<string, Set<number>>();
+
+    // Map from font key to PdfFontHandle (lazily created)
+    private readonly fonts = new Map<string, PdfFontHandle>();
+
+    // Counter for generating unique font resource names
+    private fontCounter = 0;
+
+    constructor(private readonly encoding: "identity" | "sequential" = "identity") {}
+
+    /**
+     * Generates a stable key for a UnifiedFont.
+     * Uses CSS metadata if available, otherwise falls back to a generic key.
+     */
+    private fontKey(font: UnifiedFont): string {
+        if (font.css) {
+            const { family, weight, style } = font.css;
+            return `${family}|${weight}|${style}`;
+        }
+
+        // Fallback: use unitsPerEm and ascender as a fingerprint
+        const { unitsPerEm, ascender } = font.metrics.metrics;
+        return `_fallback_${unitsPerEm}_${ascender}`;
+    }
+
+    /**
+     * Registers a GlyphRun, collecting its glyph IDs for later subsetting.
+     */
+    registerGlyphRun(run: GlyphRun): void {
+        const key = this.fontKey(run.font);
+        let usage = this.glyphUsage.get(key);
+
+        if (!usage) {
+            usage = new Set<number>();
+            this.glyphUsage.set(key, usage);
+        }
+
+        // Add all glyph IDs from this run
+        for (const gid of run.glyphIds) {
+            usage.add(gid);
+        }
+    }
+
+    /**
+     * Ensures a font subset exists for the given UnifiedFont.
+     * Creates the subset lazily if it doesn't exist yet.
+     */
+    ensureSubsetFor(font: UnifiedFont): PdfFontHandle {
+        const key = this.fontKey(font);
+
+        // Get the collected glyph IDs for this font
+        const usedGlyphIds = this.glyphUsage.get(key) ?? new Set<number>([0]);
+        if (!this.glyphUsage.has(key)) {
+            this.glyphUsage.set(key, usedGlyphIds);
+        }
+        usedGlyphIds.add(0);
+
+        const existing = this.fonts.get(key);
+        if (existing && this.subsetCoversGlyphs(existing.subset, usedGlyphIds)) {
+            return existing;
+        }
+
+        // Re-use the prior base name when refreshing a subset so aliases stay stable.
+        const existingBaseName = existing?.subset.name.startsWith("/") ? existing.subset.name.slice(1) : undefined;
+        const baseName = existingBaseName ?? `F${++this.fontCounter}`;
+        const subset = createPdfFontSubset({
+            baseName,
+            fontMetrics: font.metrics,
+            fontProgram: font.program,
+            usedGlyphIds,
+            encoding: this.encoding,
+        });
+
+        const handle: PdfFontHandle = {
+            subset,
+            unifiedFont: font,
+        };
+
+        this.fonts.set(key, handle);
+        return handle;
+    }
+
+    /**
+     * Checks whether an existing subset already contains every glyph we've seen.
+     */
+    private subsetCoversGlyphs(subset: PdfFontSubset, glyphs: Set<number>): boolean {
+        const inSubset = new Set(subset.glyphIds);
+        for (const gid of glyphs) {
+            if (!inSubset.has(gid)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Returns all font subsets created so far.
+     */
+    getAllSubsets(): Iterable<PdfFontHandle> {
+        return this.fonts.values();
+    }
+
+    /**
+     * Returns the total number of fonts registered.
+     */
+    getFontCount(): number {
+        return this.fonts.size;
+    }
+}

package/src/pdf/header-footer-layout.ts

@@ -0,0 +1,153 @@
+import type { HeaderFooterHTML, LayerMode, PageSize, Rect } from "./types.js";
+
+export interface HeaderFooterContext {
+  readonly hf: HeaderFooterHTML;
+  readonly pageSize: PageSize;
+  readonly baseBox: Rect;
+}
+
+export interface HeaderFooterLayout {
+  readonly headerHeightPt: number;
+  readonly footerHeightPt: number;
+  readonly headerHeightPx: number;
+  readonly footerHeightPx: number;
+  readonly layerMode: LayerMode;
+  readonly header: HeaderFooterVariants;
+  readonly footer: HeaderFooterVariants;
+  readonly clipOverflow: boolean;
+}
+
+export interface HeaderFooterVariants {
+  readonly defaultVariant?: HeaderFooterVariant;
+  readonly firstVariant?: HeaderFooterVariant;
+  readonly evenVariant?: HeaderFooterVariant;
+  readonly oddVariant?: HeaderFooterVariant;
+}
+
+export interface HeaderFooterVariant {
+  readonly content: unknown;
+  readonly maxHeightPt: number;
+  readonly maxHeightPx: number;
+}
+
+export function initHeaderFooterContext(hf: HeaderFooterHTML, pageSize: PageSize, basePageBox: Rect): HeaderFooterContext {
+  return { hf, pageSize, baseBox: basePageBox };
+}
+
+export function layoutHeaderFooterTrees(ctx: HeaderFooterContext, pxToPt: (px: number) => number): HeaderFooterLayout {
+  const headerVariants = prepareVariants(ctx.hf, pxToPt, "header");
+  const footerVariants = prepareVariants(ctx.hf, pxToPt, "footer");
+  const headerHeightPt = resolveVariantHeight(headerVariants);
+  const footerHeightPt = resolveVariantHeight(footerVariants);
+  const headerHeightPx = resolveVariantHeightPx(headerVariants);
+  const footerHeightPx = resolveVariantHeightPx(footerVariants);
+
+  return {
+    headerHeightPt,
+    footerHeightPt,
+    headerHeightPx,
+    footerHeightPx,
+    layerMode: ctx.hf.layerMode,
+    header: headerVariants,
+    footer: footerVariants,
+    clipOverflow: ctx.hf.clipOverflow,
+  };
+}
+
+export function adjustPageBoxForHf(baseBox: Rect, layout: HeaderFooterLayout): Rect {
+  return {
+    x: baseBox.x,
+    y: baseBox.y + layout.headerHeightPx,
+    width: baseBox.width,
+    height: Math.max(0, baseBox.height - layout.headerHeightPx - layout.footerHeightPx),
+  };
+}
+
+export function pickHeaderVariant(
+  layout: HeaderFooterLayout,
+  pageIndex: number,
+  totalPages: number,
+): HeaderFooterVariant | undefined {
+  return pickVariant(layout.header, pageIndex, totalPages);
+}
+
+export function pickFooterVariant(
+  layout: HeaderFooterLayout,
+  pageIndex: number,
+  totalPages: number,
+): HeaderFooterVariant | undefined {
+  return pickVariant(layout.footer, pageIndex, totalPages);
+}
+
+function prepareVariants(
+  hf: HeaderFooterHTML,
+  pxToPt: (value: number) => number,
+  position: "header" | "footer",
+): HeaderFooterVariants {
+  const maxHeightPx = position === "header" ? hf.maxHeaderHeightPx ?? 0 : hf.maxFooterHeightPx ?? 0;
+  const createVariant = (content: unknown | undefined): HeaderFooterVariant | undefined => {
+    if (!content) {
+      return undefined;
+    }
+    return {
+      content,
+      maxHeightPt: pxToPt(maxHeightPx),
+      maxHeightPx,
+    };
+  };
+
+  if (position === "header") {
+    return {
+      defaultVariant: createVariant(hf.headerHtml),
+      firstVariant: createVariant(hf.headerFirstHtml),
+      evenVariant: createVariant(hf.headerEvenHtml),
+      oddVariant: createVariant(hf.headerOddHtml),
+    };
+  }
+
+  return {
+    defaultVariant: createVariant(hf.footerHtml),
+    firstVariant: createVariant(hf.footerFirstHtml),
+    evenVariant: createVariant(hf.footerEvenHtml),
+    oddVariant: createVariant(hf.footerOddHtml),
+  };
+}
+
+function resolveVariantHeight(variants: HeaderFooterVariants): number {
+  const heights = [
+    variants.defaultVariant?.maxHeightPt ?? 0,
+    variants.firstVariant?.maxHeightPt ?? 0,
+    variants.evenVariant?.maxHeightPt ?? 0,
+    variants.oddVariant?.maxHeightPt ?? 0,
+  ];
+  return Math.max(...heights);
+}
+
+function resolveVariantHeightPx(variants: HeaderFooterVariants): number {
+  const heights = [
+    variants.defaultVariant?.maxHeightPx ?? 0,
+    variants.firstVariant?.maxHeightPx ?? 0,
+    variants.evenVariant?.maxHeightPx ?? 0,
+    variants.oddVariant?.maxHeightPx ?? 0,
+  ];
+  return Math.max(...heights);
+}
+
+function pickVariant(
+  variants: HeaderFooterVariants,
+  pageIndex: number,
+  totalPages: number,
+): HeaderFooterVariant | undefined {
+  if (pageIndex === 1 && variants.firstVariant) {
+    return variants.firstVariant;
+  }
+  if (totalPages > 1) {
+    if (pageIndex % 2 === 0 && variants.evenVariant) {
+      return variants.evenVariant;
+    }
+    if (pageIndex % 2 === 1 && variants.oddVariant) {
+      return variants.oddVariant;
+    }
+  }
+  return variants.defaultVariant;
+}