pagyra-js 0.0.1

package/src/debug/audit.ts

@@ -0,0 +1,20 @@
+import { log } from "../logging/debug.js";
+
+export function auditRuns(lineRuns: { text: string, face: string }[]) {
+  const recon = lineRuns.map(r => r.text).join("");
+  const isolates = lineRuns
+    .map((r, i) => ({ i, r }))
+    .filter(x => [...x.r.text].length === 1 && /[^\u0000-\u007f]/.test(x.r.text));
+  const switches = lineRuns.reduce((acc, r, i, arr) => i > 0 && arr[i - 1].face !== r.face ? acc + 1 : acc, 0);
+
+  log("layout", "info", "Line audit", {
+    recon: recon.length > 80 ? recon.slice(0, 77) + "..." : recon,
+    isolates: isolates.map(x => ({
+      idx: x.i,
+      ch: x.r.text,
+      cp: x.r.text.codePointAt(0)!.toString(16),
+      face: x.r.face
+    })),
+    switches
+  });
+}

package/src/debug/ids.ts

@@ -0,0 +1,13 @@
+let seq = 1;
+export type UID = number;
+export function newId(): UID { return seq++; }
+
+export const DomIds = new WeakMap<object, UID>();
+export const RenderIds = new WeakMap<object, UID>();
+export const LayoutIds = new WeakMap<object, UID>();
+
+export function ensureId<T extends object>(map: WeakMap<object, UID>, node: T): UID {
+  let id = map.get(node);
+  if (!id) { id = newId(); map.set(node, id); }
+  return id;
+}

package/src/debug/log.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureDebug = configureDebug;
+exports.log = log;
+exports.preview = preview;
+var CURRENT_LEVEL = "INFO";
+var ENABLED = new Set();
+function configureDebug(level, cats) {
+    if (cats === void 0) { cats = []; }
+    CURRENT_LEVEL = level;
+    ENABLED = new Set(cats);
+}
+var order = ["ERROR", "WARN", "INFO", "DEBUG", "TRACE"];
+function allowed(level, cat) {
+    return order.indexOf(level) <= order.indexOf(CURRENT_LEVEL) && (ENABLED.size === 0 || ENABLED.has(cat));
+}
+function log(cat, level, msg, extra) {
+    if (!allowed(level, cat))
+        return;
+    var prefix = "[".concat(cat, "] ").concat(level);
+    extra ? console.log(prefix, msg, extra) : console.log(prefix, msg);
+}
+function preview(s, n) {
+    if (n === void 0) { n = 60; }
+    if (s == null)
+        return s;
+    return s.length > n ? s.slice(0, n - 3) + "..." : s;
+}

package/src/debug/log.ts

@@ -0,0 +1,52 @@
+import { configureDebug as configureNewDebug, log as newLog, type LogLevel as NewLogLevel } from "../logging/debug.js";
+
+/**
+ * @deprecated Use src/logging/debug.ts instead. This shim forwards to the new logger.
+ */
+export type LogLevel = "ERROR" | "WARN" | "INFO" | "DEBUG" | "TRACE";
+
+export type LogCat = "PARSE" | "STYLE" | "LAYOUT" | "RENDER_TREE" | "PAINT" | "ENCODING" | "FONT" | "SHADING" | "PDF" | "PAINT_TRACE";
+
+const LEVEL_MAP: Record<LogLevel, NewLogLevel> = {
+  ERROR: "error",
+  WARN: "warn",
+  INFO: "info",
+  DEBUG: "debug",
+  TRACE: "trace",
+};
+
+let warned = false;
+function warnDeprecated(): void {
+  if (!warned) {
+    console.warn("[pagyra] src/debug/log.ts is deprecated; import from src/logging/debug.ts instead.");
+    warned = true;
+  }
+}
+
+function normalizeCategory(cat: LogCat): string {
+  switch (cat) {
+    case "RENDER_TREE":
+      return "layout";
+    case "PAINT_TRACE":
+    case "SHADING":
+      return "paint";
+    default:
+      return cat.toLowerCase();
+  }
+}
+
+export function configureDebug(level: LogLevel, cats: LogCat[] = []): void {
+  warnDeprecated();
+  const normalizedCats = cats.map(normalizeCategory);
+  configureNewDebug({ level: LEVEL_MAP[level], cats: normalizedCats });
+}
+
+export function log(cat: LogCat, level: LogLevel, msg: string, extra?: unknown): void {
+  warnDeprecated();
+  newLog(normalizeCategory(cat), LEVEL_MAP[level], msg, extra);
+}
+
+export function preview(s: string, n = 60) {
+  if (s == null) return s;
+  return s.length > n ? s.slice(0, n - 3) + "..." : s;
+}

package/src/debug/tree.ts

@@ -0,0 +1,57 @@
+import { ensureId, DomIds } from "./ids.js";
+import type { UID } from "./ids.js";
+import { log } from "../logging/debug.js";
+
+export interface TreeMeta {
+  id: UID; depth: number; parentId?: UID;
+  prevSiblingId?: UID; nextSiblingId?: UID;
+  siblingIndex: number; siblingCount: number;
+  path: string;
+}
+
+export function analyzeDomNode(node: Node, parent?: Node, depth = 0): TreeMeta {
+  const id = ensureId(DomIds, node);
+  const parentId = parent ? ensureId(DomIds, parent) : undefined;
+
+  const siblings = parent ? Array.from((parent as Element).childNodes) : [node];
+  const idx = siblings.indexOf(node);
+  const siblingCount = siblings.length;
+  const prev = idx > 0 ? siblings[idx - 1] : undefined;
+  const next = idx >= 0 && idx < siblingCount - 1 ? siblings[idx + 1] : undefined;
+  const prevSiblingId = prev ? ensureId(DomIds, prev) : undefined;
+  const nextSiblingId = next ? ensureId(DomIds, next) : undefined;
+
+  const path = computeDomPath(node as Element);
+  const meta: TreeMeta = { id, depth, parentId, prevSiblingId, nextSiblingId, siblingIndex: idx, siblingCount, path };
+
+  log("parse","trace","DOM node", {
+    ...meta,
+    tag: (node as Element).nodeType === 1 ? (node as Element).tagName.toLowerCase() : "#text",
+    textPreview: node.nodeType === 3 ? (node.textContent ?? "").slice(0,60) : undefined
+  });
+  return meta;
+}
+
+export function computeDomPath(el: Element): string {
+  if (!el || el.nodeType !== 1) return "#text";
+  const parts: string[] = [];
+  let cur: Element | null = el;
+  while (cur && cur.nodeType === 1) {
+    const current: Element = cur;
+    const tag = current.tagName.toLowerCase();
+    const parent: Element | null = current.parentElement;
+    let nth = 1;
+    if (parent) {
+      const siblings = Array.from(parent.children) as Element[];
+      const sameTagSiblings = siblings.filter((candidate) => candidate.tagName === current.tagName);
+      if (sameTagSiblings.length > 1) {
+        nth = sameTagSiblings.indexOf(current) + 1;
+      }
+    }
+    const id = current.id ? `#${current.id}` : "";
+    const cls = current.classList?.length ? "." + Array.from(current.classList).join(".") : "";
+    parts.unshift(`${tag}${id}${cls}${parent && nth>1 ? `:nth-of-type(${nth})` : ""}`);
+    cur = parent;
+  }
+  return parts.join(">");
+}

package/src/dom/node.ts

@@ -0,0 +1,133 @@
+import { ComputedStyle } from "../css/style.js";
+import { Box } from "../geometry/box.js";
+import type { LineBox } from "../text/line-breaker.js";
+
+export interface InlineRun {
+  lineIndex: number;
+  startX: number;
+  baseline: number;
+  text: string;
+  width: number;
+  lineWidth: number;
+  spaceCount: number;
+  targetWidth: number;
+  isLastLine: boolean;
+}
+
+export interface NodeVisitor {
+  (node: LayoutNode): void;
+}
+
+export interface LayoutNodeOptions {
+  intrinsicInlineSize?: number;
+  intrinsicBlockSize?: number;
+  textContent?: string;
+  tagName?: string;
+  lineBoxes?: LineBox[];
+  inlineRuns?: InlineRun[];
+  customData?: Record<string, unknown>;
+  tableColSpan?: number;
+  tableRowSpan?: number;
+  tableCellOrigin?: { row: number; col: number };
+}
+
+export class LayoutNode {
+  readonly box = new Box();
+  parent: LayoutNode | null = null;
+  private readonly childrenInternal: LayoutNode[] = [];
+
+  establishesBFC = false;
+  establishesIFC = false;
+  establishesFFC = false;
+  establishesGFC = false;
+  establishesTFC = false;
+
+  intrinsicInlineSize?: number;
+  intrinsicBlockSize?: number;
+  textContent?: string;
+  tagName?: string;
+  lineBoxes?: LineBox[];
+  inlineRuns?: InlineRun[];
+  customData?: Record<string, unknown>;
+  tableColSpan?: number;
+  tableRowSpan?: number;
+  tableCellOrigin?: { row: number; col: number };
+
+  constructor(public readonly style: ComputedStyle, children: Iterable<LayoutNode> = [], options?: LayoutNodeOptions) {
+    this.intrinsicInlineSize = options?.intrinsicInlineSize;
+    this.intrinsicBlockSize = options?.intrinsicBlockSize;
+    this.textContent = options?.textContent;
+    this.tagName = options?.tagName;
+    this.lineBoxes = options?.lineBoxes;
+    this.inlineRuns = options?.inlineRuns;
+    this.customData = options?.customData;
+    this.tableColSpan = options?.tableColSpan;
+    this.tableRowSpan = options?.tableRowSpan;
+    this.tableCellOrigin = options?.tableCellOrigin;
+    for (const child of children) {
+      this.appendChild(child);
+    }
+  }
+
+  get children(): readonly LayoutNode[] {
+    return this.childrenInternal;
+  }
+
+  appendChild(child: LayoutNode): this {
+    child.parent = this;
+    this.childrenInternal.push(child);
+    return this;
+  }
+
+  removeChild(child: LayoutNode): void {
+    const idx = this.childrenInternal.indexOf(child);
+    if (idx >= 0) {
+      this.childrenInternal.splice(idx, 1);
+      child.parent = null;
+    }
+  }
+
+  nearestAncestor(predicate: (node: LayoutNode) => boolean): LayoutNode | null {
+    let current: LayoutNode | null = this.parent;
+    while (current) {
+      if (predicate(current)) {
+        return current;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+
+  walk(visitor: NodeVisitor, includeSelf = true): void {
+    if (includeSelf) {
+      visitor(this);
+    }
+    for (const child of this.childrenInternal) {
+      child.walk(visitor, true);
+    }
+  }
+
+  postOrder(visitor: NodeVisitor): void {
+    for (const child of this.childrenInternal) {
+      child.postOrder(visitor);
+    }
+    visitor(this);
+  }
+
+  shift(dx: number, dy: number): void {
+    this.box.x += dx;
+    this.box.y += dy;
+    this.box.baseline += dy;
+
+    if (this.inlineRuns) {
+      for (const run of this.inlineRuns) {
+        run.startX += dx;
+        run.baseline += dy;
+      }
+    }
+
+    for (const child of this.childrenInternal) {
+      child.shift(dx, dy);
+    }
+  }
+}

package/src/environment/browser-environment.ts

@@ -0,0 +1,78 @@
+/**
+ * Browser implementation of the Environment interfaces.
+ * Uses fetch for loading and DecompressionStream for inflateRaw (with a guard).
+ */
+import type { Compression, Environment, ResourceLoader } from "./environment.js";
+
+class BrowserLoader implements ResourceLoader {
+  async load(source: string): Promise<ArrayBuffer> {
+    const response = await fetch(source);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch resource: ${source} (${response.status})`);
+    }
+    return await response.arrayBuffer();
+  }
+}
+
+const DecompressionStreamCtor: typeof DecompressionStream | undefined = (globalThis as any).DecompressionStream;
+
+class BrowserCompression implements Compression {
+  async inflateRaw(data: Uint8Array): Promise<Uint8Array> {
+    if (!DecompressionStreamCtor) {
+      throw new Error("DecompressionStream not available; provide a polyfill (e.g., pako) for inflateRaw.");
+    }
+    const stream = new DecompressionStreamCtor("deflate-raw");
+    const writer = stream.writable.getWriter();
+    await writer.write(new Uint8Array(data) as BufferSource);
+    await writer.close();
+    const reader = stream.readable.getReader();
+    const chunks: Uint8Array[] = [];
+    let total = 0;
+    for (; ;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return out;
+  }
+}
+
+export class BrowserEnvironment implements Environment {
+  readonly loader: ResourceLoader;
+  readonly compression: Compression;
+
+  constructor() {
+    this.loader = new BrowserLoader();
+    this.compression = new BrowserCompression();
+  }
+
+  resolveLocal(source: string, base?: string): string {
+    if (/^data:/i.test(source)) return source;
+    if (/^[a-z][a-z0-9+\-.]*:\/\//i.test(source) || source.startsWith("//")) {
+      return source;
+    }
+    if (base) {
+      try {
+        return new URL(source, base).toString();
+      } catch {
+        // ignore and fall through
+      }
+    }
+    throw new Error(`Local path resolution is not supported in browser environment: ${source}`);
+  }
+
+  now(): number {
+    return typeof performance !== "undefined" ? performance.now() : Date.now();
+  }
+
+  getEnv(_name: string): string | undefined {
+    return undefined;
+  }
+}

package/src/environment/environment.ts

@@ -0,0 +1,35 @@
+/**
+ * Environment abstractions to decouple platform-specific I/O from core logic.
+ * Node and browser builds should provide their own implementations.
+ */
+export interface ResourceLoader {
+  /**
+   * Load a binary resource (font, image, etc.) from a URL or path.
+   */
+  load(source: string): Promise<ArrayBuffer>;
+}
+
+export interface Compression {
+  /**
+   * Inflate raw deflate-compressed data (no zlib headers).
+   */
+  inflateRaw(data: Uint8Array): Promise<Uint8Array>;
+}
+
+export interface Environment {
+  readonly loader: ResourceLoader;
+  readonly compression: Compression;
+  /**
+   * Resolve a local reference (path or URL-like) relative to a base.
+   * Implementations may throw if local resolution isn't supported (e.g., browser).
+   */
+  resolveLocal?(source: string, base?: string): string;
+  /**
+   * Monotonic-ish clock for timing/debug (milliseconds).
+   */
+  now(): number;
+  /**
+   * Get an environment variable.
+   */
+  getEnv(name: string): string | undefined;
+}

package/src/environment/global.ts

@@ -0,0 +1,13 @@
+/**
+ * Helper to set the global environment for browser builds.
+ * Use this to avoid threading Environment through every call when bootstrapping.
+ */
+import type { Environment } from "./environment.js";
+
+export function setGlobalEnvironment(env: Environment): void {
+  (globalThis as any).__PAGYRA_ENV__ = env;
+}
+
+export function getGlobalEnvironment(): Environment | undefined {
+  return (globalThis as any).__PAGYRA_ENV__ as Environment | undefined;
+}

package/src/environment/node-environment.browser.ts

@@ -0,0 +1,28 @@
+// Browser stub: NodeEnvironment is unavailable in browser builds.
+import type { Environment, ResourceLoader, Compression } from "./environment.js";
+
+class NoopLoader implements ResourceLoader {
+  async load(_source: string): Promise<ArrayBuffer> {
+    throw new Error("NodeEnvironment is not available in browser builds");
+  }
+}
+
+class NoopCompression implements Compression {
+  async inflateRaw(_data: Uint8Array): Promise<Uint8Array> {
+    throw new Error("NodeEnvironment compression is not available in browser builds");
+  }
+}
+
+export class NodeEnvironment implements Environment {
+  readonly loader: ResourceLoader = new NoopLoader();
+  readonly compression: Compression = new NoopCompression();
+  resolveLocal(): string {
+    throw new Error("NodeEnvironment resolveLocal is not available in browser builds");
+  }
+  now(): number {
+    return typeof performance !== "undefined" ? performance.now() : Date.now();
+  }
+  getEnv(_name: string): string | undefined {
+    return undefined;
+  }
+}

package/src/environment/node-environment.ts

@@ -0,0 +1,64 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { inflateRawSync } from "node:zlib";
+import type { Compression, Environment, ResourceLoader } from "./environment.js";
+
+class NodeLoader implements ResourceLoader {
+  constructor(private readonly baseDir?: string) { }
+
+  async load(source: string): Promise<ArrayBuffer> {
+    if (/^https?:\/\//i.test(source)) {
+      const res = await fetch(source);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch resource: ${source} (${res.status})`);
+      }
+      return await res.arrayBuffer();
+    }
+
+    const resolved = this.baseDir ? path.resolve(this.baseDir, source) : source;
+    const buffer = await readFile(resolved);
+    const bytes = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    return bytes.slice().buffer;
+  }
+}
+
+class NodeCompression implements Compression {
+  async inflateRaw(data: Uint8Array): Promise<Uint8Array> {
+    const inflated = inflateRawSync(data);
+    return new Uint8Array(inflated.buffer, inflated.byteOffset, inflated.byteLength);
+  }
+}
+
+/**
+ * Default Node environment implementation.
+ * Base directory is optional and used for resolving relative file paths.
+ */
+export class NodeEnvironment implements Environment {
+  readonly loader: ResourceLoader;
+  readonly compression: Compression;
+
+  constructor(baseDir?: string) {
+    this.loader = new NodeLoader(baseDir);
+    this.compression = new NodeCompression();
+  }
+
+  resolveLocal(source: string, base?: string): string {
+    // URLs and data URIs pass through unchanged
+    if (/^(https?:)?\/\//i.test(source) || /^data:/i.test(source)) {
+      return source;
+    }
+    // Strip leading slash to treat as document-relative (not filesystem-absolute)
+    // This ensures /images/duck.jpg resolves to {base}/images/duck.jpg, not C:\images\duck.jpg on Windows
+    const normalized = source.startsWith('/') ? source.slice(1) : source;
+    const resolved = base ? path.resolve(base, normalized) : path.resolve(normalized);
+    return resolved;
+  }
+
+  now(): number {
+    return Date.now();
+  }
+
+  getEnv(name: string): string | undefined {
+    return process.env[name];
+  }
+}

package/src/fonts/detector.ts

@@ -0,0 +1,28 @@
+import type { FontFormat } from './types.js';
+
+export function detectFontFormat(fontData: Uint8Array): FontFormat | null {
+  if (fontData.length < 4) {
+    return null;
+  }
+
+  // Read the first 4 bytes as signature
+  const signature = String.fromCharCode(...fontData.slice(0, 4));
+
+  switch (signature) {
+    case 'wOFF':
+      return 'woff';
+    case 'wOF2':
+      return 'woff2';
+    case '\x00\x01\x00\x00': // TTF/OTF signature
+    case 'OTTO': // OTF signature
+      // For simplicity, we'll treat both TTF and OTF as 'ttf' for now
+      // Later we can differentiate if needed
+      return fontData[0] === 0 && fontData[1] === 1 ? 'ttf' : 'otf';
+    default:
+      return null;
+  }
+}
+
+export function isSupportedFontFormat(fontData: Uint8Array): boolean {
+  return detectFontFormat(fontData) !== null;
+}

package/src/fonts/engines/ttf-engine.ts

@@ -0,0 +1,28 @@
+import { parseTtfBuffer } from '../../pdf/font/ttf-lite.js';
+import type { TtfFontMetrics } from '../../types/fonts.js';
+import type { UnifiedFont, FontFormat } from '../types.js';
+
+export class TtfEngine {
+  parse(fontData: Uint8Array): TtfFontMetrics {
+    const arrayBuffer = new ArrayBuffer(fontData.length);
+    const view = new Uint8Array(arrayBuffer);
+    view.set(fontData);
+    return parseTtfBuffer(arrayBuffer);
+  }
+
+  convertToUnified(parsedFont: TtfFontMetrics): UnifiedFont {
+    return {
+      metrics: {
+        metrics: parsedFont.metrics,
+        glyphMetrics: parsedFont.glyphMetrics,
+        cmap: parsedFont.cmap,
+        headBBox: parsedFont.headBBox,
+      },
+      program: {
+        sourceFormat: 'ttf' as FontFormat,
+        getRawTableData: undefined, // TTF engine doesn't have raw table access
+        getGlyphOutline: parsedFont.getGlyphOutline,
+      },
+    };
+  }
+}

package/src/fonts/engines/woff-engine.ts

@@ -0,0 +1,38 @@
+import { decodeWoff } from "../woff/decoder.js";
+import { reconstructTtf } from "../utils/ttf-reconstructor.js";
+import type { FontFormat, ParsedFont, UnifiedFont } from "../types.js";
+import { parseTtfBuffer } from "../../pdf/font/ttf-lite.js";
+
+export class WoffEngine {
+  async parse(fontData: Uint8Array): Promise<ParsedFont> {
+    return decodeWoff(fontData);
+  }
+
+  convertToUnified(parsedFont: ParsedFont): UnifiedFont {
+    const ttfBuffer = reconstructTtf(parsedFont);
+    const metrics = parseTtfBuffer(ttfBuffer);
+
+    // Capture raw table data for callers that need it (PDF embedding/tests)
+    const tableMap = new Map<string, Uint8Array>();
+    for (const [tag, data] of Object.entries(parsedFont.tables)) {
+      tableMap.set(tag, data);
+    }
+
+    return {
+      metrics: {
+        metrics: metrics.metrics,
+        glyphMetrics: metrics.glyphMetrics,
+        cmap: metrics.cmap,
+        headBBox: metrics.headBBox,
+        kerning: metrics.kerning,
+      },
+      program: {
+        sourceFormat: "woff" as FontFormat,
+        unitsPerEm: metrics.metrics.unitsPerEm,
+        glyphCount: metrics.glyphMetrics.size,
+        getRawTableData: (tag: string) => tableMap.get(tag) ?? null,
+        getGlyphOutline: metrics.getGlyphOutline,
+      }
+    };
+  }
+}

package/src/fonts/engines/woff2-engine.ts

@@ -0,0 +1,41 @@
+import { parseTtfBuffer } from "../../pdf/font/ttf-lite.js";
+import type { FontFormat, ParsedFont, UnifiedFont } from "../types.js";
+import { decodeWoff2 } from "../woff2/decoder.js";
+
+type ParsedWoff2 = ParsedFont & { ttfBuffer: Uint8Array };
+
+export class Woff2Engine {
+  async parse(fontData: Uint8Array): Promise<ParsedWoff2> {
+    const { parsed, ttfBuffer } = await decodeWoff2(fontData);
+    return { ...parsed, ttfBuffer };
+  }
+
+  convertToUnified(parsedFont: ParsedWoff2): UnifiedFont {
+    // Create an ArrayBuffer copy to avoid SharedArrayBuffer unions
+    const ttfCopy = parsedFont.ttfBuffer.slice();
+    const ttfArrayBuffer = ttfCopy.buffer;
+    const metrics = parseTtfBuffer(ttfArrayBuffer);
+
+    const tableMap = new Map<string, Uint8Array>();
+    for (const [tag, data] of Object.entries(parsedFont.tables)) {
+      tableMap.set(tag, data);
+    }
+
+    return {
+      metrics: {
+        metrics: metrics.metrics,
+        glyphMetrics: metrics.glyphMetrics,
+        cmap: metrics.cmap,
+        headBBox: metrics.headBBox,
+        kerning: metrics.kerning
+      },
+      program: {
+        sourceFormat: "woff2" as FontFormat,
+        unitsPerEm: metrics.metrics.unitsPerEm,
+        glyphCount: metrics.glyphMetrics.size,
+        getRawTableData: (tag: string) => tableMap.get(tag) ?? null,
+        getGlyphOutline: metrics.getGlyphOutline
+      }
+    };
+  }
+}