pagyra-js 0.0.1

package/src/pdf/utils/drop-shadow-raster.ts

@@ -0,0 +1,233 @@
+import type { Radius, Rect, RGBA, ImageRef } from "../types.js";
+
+function clampUnit(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  if (value <= 0) return 0;
+  if (value >= 1) return 1;
+  return value;
+}
+
+function ceilPositive(value: number): number {
+  if (!Number.isFinite(value) || value <= 0) return 0;
+  return Math.ceil(value);
+}
+
+function inflateRect(rect: Rect, amount: number): Rect {
+  const width = rect.width + amount * 2;
+  const height = rect.height + amount * 2;
+  if (width <= 0 || height <= 0) {
+    return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2, width: 0, height: 0 };
+  }
+  return { x: rect.x - amount, y: rect.y - amount, width, height };
+}
+
+function max2(a: number, b: number): number { return a > b ? a : b; }
+
+function pointInRoundedRect(px: number, py: number, rect: Rect, radius: Radius): boolean {
+  if (px < rect.x || py < rect.y || px > rect.x + rect.width || py > rect.y + rect.height) {
+    return false;
+  }
+
+  const leftMargin = max2(radius.topLeft.x, radius.bottomLeft.x);
+  const rightMargin = max2(radius.topRight.x, radius.bottomRight.x);
+  const topMargin = max2(radius.topLeft.y, radius.topRight.y);
+  const bottomMargin = max2(radius.bottomLeft.y, radius.bottomRight.y);
+
+  // Horizontal and vertical straight strips
+  if (px >= rect.x + leftMargin && px <= rect.x + rect.width - rightMargin) return true;
+  if (py >= rect.y + topMargin && py <= rect.y + rect.height - bottomMargin) return true;
+
+  // Corner tests (elliptical)
+  // Top-left
+  if (px < rect.x + radius.topLeft.x && py < rect.y + radius.topLeft.y && radius.topLeft.x > 0 && radius.topLeft.y > 0) {
+    const cx = rect.x + radius.topLeft.x;
+    const cy = rect.y + radius.topLeft.y;
+    const dx = (px - cx) / radius.topLeft.x;
+    const dy = (py - cy) / radius.topLeft.y;
+    return dx * dx + dy * dy <= 1;
+  }
+  // Top-right
+  if (px > rect.x + rect.width - radius.topRight.x && py < rect.y + radius.topRight.y && radius.topRight.x > 0 && radius.topRight.y > 0) {
+    const cx = rect.x + rect.width - radius.topRight.x;
+    const cy = rect.y + radius.topRight.y;
+    const dx = (px - cx) / radius.topRight.x;
+    const dy = (py - cy) / radius.topRight.y;
+    return dx * dx + dy * dy <= 1;
+  }
+  // Bottom-right
+  if (px > rect.x + rect.width - radius.bottomRight.x && py > rect.y + rect.height - radius.bottomRight.y && radius.bottomRight.x > 0 && radius.bottomRight.y > 0) {
+    const cx = rect.x + rect.width - radius.bottomRight.x;
+    const cy = rect.y + rect.height - radius.bottomRight.y;
+    const dx = (px - cx) / radius.bottomRight.x;
+    const dy = (py - cy) / radius.bottomRight.y;
+    return dx * dx + dy * dy <= 1;
+  }
+  // Bottom-left
+  if (px < rect.x + radius.bottomLeft.x && py > rect.y + rect.height - radius.bottomLeft.y && radius.bottomLeft.x > 0 && radius.bottomLeft.y > 0) {
+    const cx = rect.x + radius.bottomLeft.x;
+    const cy = rect.y + rect.height - radius.bottomLeft.y;
+    const dx = (px - cx) / radius.bottomLeft.x;
+    const dy = (py - cy) / radius.bottomLeft.y;
+    return dx * dx + dy * dy <= 1;
+  }
+  return false;
+}
+
+function buildGaussianKernel(sigma: number): { kernel: Float32Array; radius: number; sum: number } {
+  const s = sigma > 0 ? sigma : 0.0001;
+  const radius = Math.max(1, Math.ceil(s * 3));
+  const size = radius * 2 + 1;
+  const kernel = new Float32Array(size);
+  const coeff = 1 / (Math.sqrt(2 * Math.PI) * s);
+  const twoSigmaSq = 2 * s * s;
+  let sum = 0;
+  for (let i = -radius; i <= radius; i++) {
+    const w = coeff * Math.exp(-(i * i) / twoSigmaSq);
+    kernel[i + radius] = w;
+    sum += w;
+  }
+  return { kernel, radius, sum };
+}
+
+function blurAlpha(alpha: Uint8Array, width: number, height: number, sigma: number): Uint8Array {
+  if (sigma <= 0) return alpha;
+  const { kernel, radius, sum } = buildGaussianKernel(sigma);
+  const tmp = new Float32Array(width * height);
+  // Horizontal pass
+  for (let y = 0; y < height; y++) {
+    const rowOffset = y * width;
+    for (let x = 0; x < width; x++) {
+      let acc = 0;
+      let wsum = 0;
+      for (let k = -radius; k <= radius; k++) {
+        const xi = Math.min(width - 1, Math.max(0, x + k));
+        const w = kernel[k + radius];
+        acc += alpha[rowOffset + xi] * w;
+        wsum += w;
+      }
+      tmp[rowOffset + x] = acc / (wsum || sum);
+    }
+  }
+  // Vertical pass
+  const out = new Uint8Array(width * height);
+  for (let x = 0; x < width; x++) {
+    for (let y = 0; y < height; y++) {
+      let acc = 0;
+      let wsum = 0;
+      for (let k = -radius; k <= radius; k++) {
+        const yi = Math.min(height - 1, Math.max(0, y + k));
+        const w = kernel[k + radius];
+        acc += tmp[yi * width + x] * w;
+        wsum += w;
+      }
+      const v = acc / (wsum || sum);
+      out[y * width + x] = v < 0 ? 0 : v > 255 ? 255 : v;
+    }
+  }
+  return out;
+}
+
+export interface ShadowRasterResult {
+  readonly image: ImageRef;
+  readonly drawRect: Rect; // where to place the image in page coordinates (px)
+}
+
+export function rasterizeDropShadowForRect(
+  baseRect: Rect,
+  baseRadius: Radius,
+  color: RGBA,
+  blur: number,
+  spread: number,
+): ShadowRasterResult | null {
+  const blurPx = Math.max(0, blur);
+  const shapeRect: Rect = inflateRect(baseRect, spread);
+  const shapeRadius: Radius = adjustRadius(baseRadius, spread);
+  const outRect: Rect = inflateRect(shapeRect, blurPx);
+  const width = ceilPositive(outRect.width);
+  const height = ceilPositive(outRect.height);
+  if (width === 0 || height === 0) {
+    return null;
+  }
+
+  // Build alpha mask for the unblurred rounded rectangle (shapeRect within outRect)
+  const alpha = new Uint8Array(width * height);
+  const shapeLocal: Rect = { x: shapeRect.x - outRect.x, y: shapeRect.y - outRect.y, width: shapeRect.width, height: shapeRect.height };
+
+  for (let y = 0; y < height; y++) {
+    const py = y + 0.5; // pixel center
+    for (let x = 0; x < width; x++) {
+      const px = x + 0.5;
+      const inside = pointInRoundedRect(px, py, shapeLocal, shapeRadius);
+      alpha[y * width + x] = inside ? 255 : 0;
+    }
+  }
+
+  const sigma = blurPx > 0 ? Math.max(0.5, blurPx / 2) : 0;
+  const blurred = blurAlpha(alpha, width, height, sigma);
+
+  // Compose RGBA data with straight alpha (non-premultiplied RGB)
+  // sRGB compensation: push base color slightly towards display sRGB to better match browser compositing
+  const [r, g, b] = compensateSrgbColor(color.r, color.g, color.b);
+  const aMul = clampUnit(color.a ?? 1);
+  const data = new Uint8Array(width * height * 4);
+  let di = 0;
+  for (let i = 0; i < blurred.length; i++) {
+    data[di++] = r;
+    data[di++] = g;
+    data[di++] = b;
+    const a = Math.round(blurred[i] * aMul);
+    data[di++] = a < 0 ? 0 : a > 255 ? 255 : a;
+  }
+
+  const image: ImageRef = {
+    src: `internal:shadow:${Math.random().toString(36).slice(2)}`,
+    width,
+    height,
+    format: "png",
+    channels: 4,
+    bitsPerComponent: 8,
+    data: data.buffer,
+  };
+
+  return { image, drawRect: outRect };
+}
+
+function adjustRadius(radius: Radius, delta: number): Radius {
+  const clampNN = (v: number) => (Number.isFinite(v) && v > 0 ? v : 0);
+  return {
+    topLeft: { x: clampNN(radius.topLeft.x + delta), y: clampNN(radius.topLeft.y + delta) },
+    topRight: { x: clampNN(radius.topRight.x + delta), y: clampNN(radius.topRight.y + delta) },
+    bottomRight: { x: clampNN(radius.bottomRight.x + delta), y: clampNN(radius.bottomRight.y + delta) },
+    bottomLeft: { x: clampNN(radius.bottomLeft.x + delta), y: clampNN(radius.bottomLeft.y + delta) },
+  };
+}
+
+function srgbToLinearByte(c: number): number {
+  const cs = Math.min(1, Math.max(0, c > 1 ? c / 255 : c));
+  const lin = cs <= 0.04045 ? cs / 12.92 : Math.pow((cs + 0.055) / 1.055, 2.4);
+  return lin * 255;
+}
+
+function linearToSrgbByte(c: number): number {
+  const cl = Math.min(1, Math.max(0, c > 1 ? c / 255 : c));
+  const srgb = cl <= 0.0031308 ? 12.92 * cl : 1.055 * Math.pow(cl, 1 / 2.4) - 0.055;
+  return Math.round(Math.min(255, Math.max(0, srgb * 255)));
+}
+
+// Simple compensation to reduce perceived desaturation in some PDF viewers
+function compensateSrgbColor(rIn: number, gIn: number, bIn: number): [number, number, number] {
+  // Convert to linear, nudge saturation, convert back to sRGB
+  const rl = srgbToLinearByte(rIn) / 255;
+  const gl = srgbToLinearByte(gIn) / 255;
+  const bl = srgbToLinearByte(bIn) / 255;
+  const max = Math.max(rl, gl, bl);
+  const min = Math.min(rl, gl, bl);
+  const mid = (rl + gl + bl) / 3;
+  const sat = max - min;
+  const boosted = Math.min(1, sat * 1.08); // small boost only
+  const scale = sat > 0 ? boosted / sat : 1;
+  const r = mid + (rl - mid) * scale;
+  const g = mid + (gl - mid) * scale;
+  const b = mid + (bl - mid) * scale;
+  return [linearToSrgbByte(r), linearToSrgbByte(g), linearToSrgbByte(b)];
+}

package/src/pdf/utils/encoding.ts

@@ -0,0 +1,98 @@
+import { log } from "../../logging/debug.js";
+
+const WIN_ANSI_UNICODE = (() => {
+  const table: number[] = new Array(256);
+  for (let code = 0; code <= 0xff; code++) {
+    table[code] = code;
+  }
+
+  const overrides: Record<number, number> = {
+    0x80: 0x20ac,
+    0x82: 0x201a,
+    0x83: 0x0192,
+    0x84: 0x201e,
+    0x85: 0x2026,
+    0x86: 0x2020,
+    0x87: 0x2021,
+    0x88: 0x02c6,
+    0x89: 0x2030,
+    0x8a: 0x0160,
+    0x8b: 0x2039,
+    0x8c: 0x0152,
+    0x8e: 0x017d,
+    0x91: 0x2018,
+    0x92: 0x2019,
+    0x93: 0x201c,
+    0x94: 0x201d,
+    0x95: 0x2022,
+    0x96: 0x2013,
+    0x97: 0x2014,
+    0x98: 0x02dc,
+    0x99: 0x2122,
+    0x9a: 0x0161,
+    0x9b: 0x203a,
+    0x9c: 0x0153,
+    0x9e: 0x017e,
+    0x9f: 0x0178,
+  };
+
+  for (const [codePoint, unicode] of Object.entries(overrides)) {
+    const code = Number(codePoint);
+    table[code] = unicode;
+  }
+
+  return table;
+})();
+
+const UNICODE_TO_WIN_ANSI = (() => {
+  const map = new Map<number, number>();
+  for (let code = 0; code <= 0xff; code++) {
+    const unicode = WIN_ANSI_UNICODE[code];
+    if (!map.has(unicode)) {
+      map.set(unicode, code);
+    }
+  }
+  return map;
+})();
+
+export { UNICODE_TO_WIN_ANSI };
+
+export type PdfEncodingScheme = "WinAnsi" | "Identity-H";
+
+export function encodeToWinAnsi(text: string): string {
+  let result = "",
+    misses = 0,
+    details: number[] = [];
+  for (const char of text) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === undefined) {
+      continue;
+    }
+    const byte = UNICODE_TO_WIN_ANSI.get(codePoint);
+    if (byte === undefined) {
+      misses++;
+      details.push(codePoint);
+      result += "?";
+      continue;
+    }
+    result += String.fromCharCode(byte);
+  }
+  if (misses) {
+    log("encoding", "debug", "WinAnsi misses", {
+      misses,
+      codepoints: details.slice(0, 20),
+    });
+  }
+  return result;
+}
+
+export function escapePdfLiteral(text: string): string {
+  return text.replace(/([()\\])/g, "\\$1");
+}
+
+export function encodeAndEscapePdfText(text: string, scheme: PdfEncodingScheme = "WinAnsi"): string {
+  const before = text;
+  const payload = scheme === "WinAnsi" ? encodeToWinAnsi(text) : text;
+  log("encoding", "trace", "PdfText transformation", { scheme, before, after: payload });
+  return escapePdfLiteral(payload);
+}

package/src/pdf/utils/glyph-atlas-registrar.ts

@@ -0,0 +1,13 @@
+import { globalGlyphAtlas } from "../font/glyph-atlas.js";
+import type { ImageRenderer } from "../renderers/image-renderer.js";
+
+export function registerGlyphAtlasPages(imageRenderer: ImageRenderer): void {
+  try {
+    const pages = globalGlyphAtlas.getPages();
+    if (pages && pages.length > 0) {
+      imageRenderer.registerAtlasPages(pages);
+    }
+  } catch {
+    // ignore atlas registration errors - fall back to per-glyph images
+  }
+}

package/src/pdf/utils/glyph-run-renderer.ts

@@ -0,0 +1,129 @@
+import type { GlyphRun } from "../../layout/text-run.js";
+import type { PdfFontSubset } from "../font/font-subset.js";
+import type { GraphicsStateManager } from "../renderers/graphics-state-manager.js";
+import { fillColorCommand, formatNumber } from "../renderers/text-renderer-utils.js";
+import type { RGBA } from "../types.js";
+
+export interface DrawGlyphRunOptions {
+  skipColor?: boolean;
+  textRenderingMode?: number;
+  afterTextCommands?: string[];
+  /** Optional text matrix (Tm) to apply instead of simple translation. Values must be in PDF user space (points). */
+  tm?: { a: number; b: number; c: number; d: number; e: number; f: number };
+}
+
+/**
+ * Draws a GlyphRun using a PdfFontSubset.
+ * Returns PDF content stream commands.
+ */
+export function drawGlyphRun(
+  run: GlyphRun,
+  subset: PdfFontSubset,
+  xPt: number,
+  yPt: number,
+  fontSizePt: number,
+  color: RGBA,
+  graphicsStateManager?: GraphicsStateManager,
+  wordSpacingPt = 0,
+  options?: DrawGlyphRunOptions,
+): string[] {
+    const commands: string[] = [];
+    if (!options?.skipColor) {
+      commands.push(fillColorCommand(color, graphicsStateManager));
+    }
+
+    // Begin text
+    commands.push("BT");
+    commands.push(`${subset.name} ${formatNumber(fontSizePt)} Tf`);
+    if (options?.tm) {
+      const { a, b, c, d, e, f } = options.tm;
+      commands.push(
+        `${formatNumber(a)} ${formatNumber(b)} ${formatNumber(c)} ${formatNumber(d)} ${formatNumber(e)} ${formatNumber(f)} Tm`,
+      );
+    } else {
+      commands.push(`${formatNumber(xPt)} ${formatNumber(yPt)} Td`);
+    }
+
+    const appliedWordSpacing = wordSpacingPt !== 0;
+    if (appliedWordSpacing) {
+      commands.push(`${formatNumber(wordSpacingPt)} Tw`);
+    }
+
+    if (options?.textRenderingMode !== undefined) {
+      commands.push(`${options.textRenderingMode} Tr`);
+    }
+
+    // Build TJ array with per-glyph kerning/letter-spacing adjustments and optional word spacing.
+    // Positions are provided in layout px units; scale to PDF points.
+    const ptPerPx = fontSizePt / run.fontSize;
+    const unitsPerEm = run.font.metrics.metrics.unitsPerEm;
+    const glyphWidths = run.font.metrics.glyphMetrics;
+    const encodeGlyphId = (gid: number): string => {
+        const charCode = subset.encodeGlyph(gid);
+        const hex = charCode.toString(16).toUpperCase();
+        // PDF expects an even number of hex digits; use at least 2 bytes for Identity-H
+        const evenHex = hex.length % 2 === 0 ? hex : `0${hex}`;
+        return evenHex.length < 4 ? evenHex.padStart(4, "0") : evenHex;
+    };
+    const elements: (string | number)[] = [];
+    let hasAdjustments = false;
+
+    for (let i = 0; i < run.glyphIds.length; i++) {
+        const gid = run.glyphIds[i];
+        const hexCode = encodeGlyphId(gid);
+        elements.push(`<${hexCode}>`);
+
+        if (i < run.glyphIds.length - 1) {
+            const currentPos = run.positions[i]?.x ?? 0;
+            const nextPos = run.positions[i + 1]?.x ?? currentPos;
+            let desiredAdvancePx = nextPos - currentPos;
+            if (appliedWordSpacing) {
+                const nextChar = run.text[i + 1] ?? "";
+                if (nextChar === " ") {
+                    // Word spacing is added on spaces; add to desired advance.
+                    desiredAdvancePx += wordSpacingPt / ptPerPx;
+                }
+            }
+
+            const gm = glyphWidths.get(gid);
+            const defaultAdvancePx = ((gm?.advanceWidth ?? 0) / unitsPerEm) * run.fontSize;
+
+            const deltaPx = desiredAdvancePx - defaultAdvancePx;
+            if (Math.abs(deltaPx) > 1e-6) {
+                const deltaPt = deltaPx * ptPerPx;
+                // TJ numbers are in thousandths of text space; positive numbers tighten spacing.
+                const adjustment = -deltaPt / fontSizePt * 1000;
+                if (Math.abs(adjustment) > 1e-6) {
+                    hasAdjustments = true;
+                    elements.push(adjustment);
+                }
+            }
+        }
+    }
+
+    if (!hasAdjustments) {
+        // Use a single hex string when there are no per-glyph adjustments; simpler and more compatible.
+        const hex = run.glyphIds.map((gid) => encodeGlyphId(gid)).join("");
+        commands.push(`<${hex}> Tj`);
+    } else {
+        const tjContent = elements
+            .map((el) => (typeof el === "number" ? formatPdfNumber(el) : el))
+            .join(" ");
+        commands.push(`[${tjContent}] TJ`);
+    }
+
+    // End text
+    commands.push("ET");
+    if (options?.afterTextCommands && options.afterTextCommands.length > 0) {
+        commands.push(...options.afterTextCommands);
+    }
+
+    return commands;
+}
+
+/**
+ * Format a number for PDF (up to 6 decimal places, trailing zeros removed).
+ */
+export function formatPdfNumber(n: number): string {
+    return n.toFixed(6).replace(/\.?0+$/, "");
+}

package/src/pdf/utils/image-command-partitioner.ts

@@ -0,0 +1,28 @@
+export interface PartitionedCommands {
+  readonly preShadow: string[];
+  readonly post: string[];
+}
+
+export function partitionImageCommands(commands: string[], shadowAliases: Set<string>): PartitionedCommands {
+  const preShadowImageCmds: string[] = [];
+  const postImageCmds: string[] = [];
+
+  for (let i = 0; i < commands.length; ) {
+    if (commands[i] === "q" && i + 3 < commands.length && commands[i + 3] === "Q") {
+      const doLine = commands[i + 2] ?? "";
+      const match = doLine.match(/^\/(\w+)\s+Do$/);
+      const block = [commands[i], commands[i + 1] ?? "", commands[i + 2] ?? "", commands[i + 3] ?? ""];
+      i += 4;
+      if (match && shadowAliases.has(match[1])) {
+        preShadowImageCmds.push(...block);
+      } else {
+        postImageCmds.push(...block);
+      }
+    } else {
+      postImageCmds.push(commands[i]);
+      i += 1;
+    }
+  }
+
+  return { preShadow: preShadowImageCmds, post: postImageCmds };
+}

package/src/pdf/utils/image-matrix-builder.ts

@@ -0,0 +1,31 @@
+import type { Rect } from "../types.js";
+import { CoordinateTransformer } from "./coordinate-transformer.js";
+
+export class ImageMatrixBuilder {
+  constructor(private readonly coordinateTransformer: CoordinateTransformer) {}
+
+  buildImageMatrix(rect: Rect): string | null {
+    if (!rect || rect.width <= 0 || rect.height <= 0) {
+      return null;
+    }
+    const widthPt = this.coordinateTransformer.convertPxToPt(rect.width);
+    const heightPt = this.coordinateTransformer.convertPxToPt(rect.height);
+    if (!Number.isFinite(widthPt) || !Number.isFinite(heightPt) || widthPt === 0 || heightPt === 0) {
+      return null;
+    }
+    const xPt = this.coordinateTransformer.convertPxToPt(rect.x);
+    const localY = rect.y - this.coordinateTransformer.pageOffsetPx;
+    const yPt = this.coordinateTransformer.pageHeightPt - this.coordinateTransformer.convertPxToPt(localY + rect.height);
+    if (!Number.isFinite(xPt) || !Number.isFinite(yPt)) {
+      return null;
+    }
+    return `${formatNumber(widthPt)} 0 0 ${formatNumber(heightPt)} ${formatNumber(xPt)} ${formatNumber(yPt)} cm`;
+  }
+}
+
+function formatNumber(value: number): string {
+  if (!Number.isFinite(value)) {
+    return "0";
+  }
+  return Number.isInteger(value) ? value.toString() : value.toFixed(4).replace(/0+$/, "").replace(/\.$/, "");
+}

package/src/pdf/utils/image-utils.ts

@@ -0,0 +1,26 @@
+import type { LayoutNode } from "../../dom/node.js";
+import type { ImageRef } from "../types.js";
+import type { ImageInfo } from "../../image/types.js";
+
+export function extractImageRef(node: LayoutNode): ImageRef | undefined {
+  if (node.tagName !== "img") {
+    return undefined;
+  }
+  const payload = node.customData?.image as
+    | { originalSrc?: string; resolvedSrc?: string; info?: ImageInfo }
+    | undefined;
+  if (!payload?.info) {
+    return undefined;
+  }
+  const info = payload.info;
+  const src = payload.resolvedSrc ?? payload.originalSrc ?? "";
+  return {
+    src,
+    width: info.width,
+    height: info.height,
+    format: info.format,
+    channels: info.channels,
+    bitsPerComponent: info.bitsPerChannel,
+    data: info.data,
+  };
+}