pagyra-js 0.0.1

package/src/pdf/renderers/text-renderer.ts

@@ -0,0 +1,391 @@
+import type { Run, TextPaintOptions, Rect } from "../types.js";
+import type { FontRegistry, FontResource } from "../font/font-registry.js";
+import type { PdfObjectRef } from "../primitives/pdf-document.js";
+import { log } from "../../logging/debug.js";
+import { CoordinateTransformer } from "../utils/coordinate-transformer.js";
+import type { ImageRenderer } from "./image-renderer.js";
+import type { GraphicsStateManager } from "./graphics-state-manager.js";
+import { fillColorCommand, formatNumber } from "./text-renderer-utils.js";
+import { TextShadowRenderer } from "./text-shadow-renderer.js";
+import { TextDecorationRenderer } from "./text-decoration-renderer.js";
+import { TextFontResolver } from "./text-font-resolver.js";
+import { encodeTextPayload } from "./text-encoder.js";
+import { drawGlyphRun } from "../utils/glyph-run-renderer.js";
+import { GradientService } from "../shading/gradient-service.js";
+import type { LinearGradient, RadialGradient } from "../../css/parsers/gradient-parser.js";
+import { transformForRect } from "./shape-utils.js";
+import type { GlyphRun } from "../../layout/text-run.js";
+import type { UnifiedFont } from "../../fonts/types.js";
+import type { Matrix } from "../../geometry/matrix.js";
+import { svgMatrixToPdf } from "../transform-adapter.js";
+
+const PINK = "\x1b[38;5;205m";
+const RESET_COLOR = "\x1b[0m";
+
+export interface TextRendererResult {
+  readonly commands: string[];
+  readonly fonts: Map<string, PdfObjectRef>;
+  readonly shadings: Map<string, string>;
+  readonly patterns: Map<string, string>;
+}
+
+export class TextRenderer {
+  private readonly commands: string[] = [];
+  private readonly fonts = new Map<string, PdfObjectRef>();
+  private readonly decorationRenderer: TextDecorationRenderer;
+  private readonly shadowRenderer: TextShadowRenderer;
+  private readonly graphicsStateManager?: GraphicsStateManager;
+  private readonly fontResolver: TextFontResolver;
+  private readonly gradientService: GradientService;
+  private readonly patterns = new Map<string, string>();
+
+  constructor(
+    private readonly coordinateTransformer: CoordinateTransformer,
+    private readonly fontRegistry: FontRegistry,
+    imageRenderer?: ImageRenderer,
+    graphicsStateManager?: GraphicsStateManager,
+  ) {
+    this.graphicsStateManager = graphicsStateManager;
+    this.fontResolver = new TextFontResolver(fontRegistry);
+    this.shadowRenderer = new TextShadowRenderer(coordinateTransformer, fontRegistry, imageRenderer, graphicsStateManager);
+    this.decorationRenderer = new TextDecorationRenderer(coordinateTransformer, graphicsStateManager);
+    this.gradientService = new GradientService(coordinateTransformer);
+  }
+
+  async drawText(text: string, xPx: number, yPx: number, options: TextPaintOptions = { fontSizePt: 10 }): Promise<void> {
+    if (!text) {
+      return;
+    }
+
+    const fontFamily = options.fontFamily ?? "Times New Roman";
+    const fontWeight = options.fontWeight ?? 400;
+    const fontStyle = options.fontStyle ?? "normal";
+    const fontVariant = options.fontVariant;
+
+    // header/footer hoje passa tamanho em pt
+    const fontSizePx = this.coordinateTransformer.convertPtToPx(options.fontSizePt);
+
+    const run: Run = {
+      text,
+      fontFamily,
+      fontWeight,
+      fontStyle,
+      fontVariant,
+      fontSize: fontSizePx,
+      letterSpacing: 0,
+      wordSpacing: 0,
+      fill: options.color ?? { r: 0, g: 0, b: 0, a: 1 },
+      lineMatrix: {
+        a: 1, b: 0, c: 0, d: 1,
+        e: xPx,
+        f: yPx, // baseline em px, igual aos outros runs
+      },
+    };
+
+    await this.drawTextRun(run);
+  }
+
+  async drawTextRun(run: Run): Promise<void> {
+    const font = await this.fontResolver.ensureFontResource({
+      fontFamily: run.fontFamily,
+      fontWeight: run.fontWeight,
+      fontStyle: run.fontStyle,
+      fontVariant: run.fontVariant,
+      text: run.text
+    });
+
+    await this.drawTextRunWithGlyphs(run, font);
+  }
+
+  private async drawTextRunWithGlyphs(run: Run, font: FontResource): Promise<void> {
+    const color = run.fill ?? { r: 0, g: 0, b: 0, a: 1 };
+    const fontSizePt = this.coordinateTransformer.convertPxToPt(run.fontSize);
+
+    let glyphRun = run.glyphs;
+    if (!glyphRun && font.metrics) {
+      glyphRun = computeGlyphRunFromText(
+        font.metrics,
+        run.text,
+        run.fontSize,
+        run.letterSpacing ?? 0,
+        {
+          family: run.fontFamily,
+          weight: run.fontWeight ?? 400,
+          style: (run.fontStyle as "normal" | "italic") ?? "normal",
+        }
+      );
+    }
+
+    if (!glyphRun) {
+      log("paint", "warn", "Skipping run without glyph data", {
+        text: run.text.slice(0, 32),
+        fontFamily: run.fontFamily,
+        fontSize: run.fontSize,
+      });
+      return;
+    }
+
+    log("paint", "debug", `${PINK}USING GLYPH RUN${RESET_COLOR}`, {
+      text: run.text.slice(0, 64),
+      glyphCount: glyphRun.glyphIds.length,
+    });
+
+    const textMatrix = buildPdfTextMatrix(run, this.coordinateTransformer);
+
+    log("paint", "debug", "drawing text run with glyphs", {
+      text: run.text.slice(0, 32),
+      glyphIds: glyphRun.glyphIds.slice(0, 10),
+      fontSizePt,
+      matrix: textMatrix,
+    });
+
+    // Normalize text for features like small-caps (match legacy behavior for shadows)
+    let normalizedText = run.text;
+    if (run.fontVariant === "small-caps") {
+      normalizedText = normalizedText.toUpperCase();
+    }
+
+    const { encoded } = encodeTextPayload(normalizedText, font);
+    const wordSpacingPx = run.wordSpacing ?? 0;
+    const wordSpacingPt = this.coordinateTransformer.convertPxToPt(wordSpacingPx);
+    const appliedWordSpacing = wordSpacingPx !== 0 && wordSpacingPt !== 0;
+
+    // Shadows use the base font resource (non-subset) for compatibility with Identity-H encoding
+    this.registerFont(font);
+    if (run.textShadows && run.textShadows.length > 0) {
+      const shadowCommands = await this.shadowRenderer.render({
+        run,
+        font,
+        encoded,
+        Tm: run.lineMatrix ?? { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 },
+        fontSizePt,
+        fontSizePx: run.fontSize,
+        wordSpacingPt,
+        appliedWordSpacing,
+        fontResourceName: font.resourceName,
+      });
+      this.commands.push(...shadowCommands);
+    }
+
+    const subsetResource = this.fontRegistry.ensureSubsetForGlyphRun(glyphRun, font);
+    this.registerSubsetFont(subsetResource.alias, subsetResource.ref);
+
+    const gradientBackground = run.textGradient;
+    if (gradientBackground && gradientBackground.rect && gradientBackground.rect.width > 0 && gradientBackground.rect.height > 0) {
+      log("paint", "debug", "text run has background clip gradient", {
+        text: run.text.slice(0, 32),
+        rect: gradientBackground.rect,
+      });
+      const gradientPaint = gradientBackground.gradient;
+      const isLinear = (gradientPaint as LinearGradient).type === "linear";
+      const isRadial = (gradientPaint as RadialGradient).type === "radial";
+      if (isLinear || isRadial) {
+        const pattern = this.gradientService.createPatternFromLinearGradient(
+          gradientPaint as LinearGradient,
+          {
+            width: gradientBackground.rect.width,
+            height: gradientBackground.rect.height,
+            x: gradientBackground.rect.x,
+            y: gradientBackground.rect.y,
+          },
+        );
+        this.patterns.set(pattern.patternName, pattern.dictionary);
+
+        const usePattern: string[] = [
+          "q",
+          `/Pattern cs`,
+          `/${pattern.patternName} scn`,
+        ];
+        const glyphPatternCommands = drawGlyphRun(
+          glyphRun,
+          subsetResource.subset,
+          0,
+          0,
+          fontSizePt,
+          color,
+          this.graphicsStateManager,
+          wordSpacingPt,
+          { skipColor: true, tm: textMatrix },
+        );
+        if (glyphPatternCommands.length > 0) {
+          this.commands.push(...usePattern, ...glyphPatternCommands, "Q");
+          if (run.decorations) {
+            this.commands.push(...this.decorationRenderer.render(run, color));
+          }
+          return;
+        }
+      }
+    }
+
+    const glyphCommands = drawGlyphRun(
+      glyphRun,
+      subsetResource.subset,
+      0,
+      0,
+      fontSizePt,
+      color,
+      this.graphicsStateManager,
+      wordSpacingPt,
+      { tm: textMatrix }
+    );
+    this.commands.push(...glyphCommands);
+
+    if (run.decorations) {
+      this.commands.push(...this.decorationRenderer.render(run, color));
+    }
+  }
+
+  private registerFont(font: FontResource): void {
+    if (!this.fonts.has(font.resourceName)) {
+      this.fonts.set(font.resourceName, font.ref);
+    }
+  }
+
+  private registerSubsetFont(alias: string, ref: PdfObjectRef): void {
+    // Always update to the latest reference so refreshed subsets are used.
+    this.fonts.set(alias, ref);
+  }
+
+  private fillGradientRect(rect: Rect, gradient: LinearGradient | RadialGradient): string[] {
+    const width = Math.max(rect.width, 0);
+    const height = Math.max(rect.height, 0);
+    if (width <= 0 || height <= 0) {
+      return [];
+    }
+    const shading =
+      gradient.type === "radial"
+        ? this.gradientService.createRadialGradient(gradient as RadialGradient, rect)
+        : this.gradientService.createLinearGradient(gradient as LinearGradient, rect);
+
+    return [
+      "q",
+      transformForRect(rect, this.coordinateTransformer, null),
+      `0 0 ${formatNumber(width)} ${formatNumber(height)} re`,
+      "W n",
+      `/${shading.shadingName} sh`,
+      "Q",
+    ];
+  }
+
+  private fillPatternRect(rect: Rect): string[] {
+    const width = Math.max(rect.width, 0);
+    const height = Math.max(rect.height, 0);
+    if (width <= 0 || height <= 0) {
+      return [];
+    }
+    return [
+      transformForRect(rect, this.coordinateTransformer, null),
+      `0 0 ${formatNumber(width)} ${formatNumber(height)} re`,
+      "f",
+    ];
+  }
+
+  getResult(): TextRendererResult {
+    return {
+      commands: [...this.commands],
+      fonts: new Map(this.fonts),
+      shadings: this.gradientService.getShadings(),
+      patterns: new Map(this.patterns),
+    };
+  }
+}
+
+function buildPdfTextMatrix(run: Run, transformer: CoordinateTransformer): Matrix {
+  const base = run.lineMatrix ?? { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
+  if (!run.lineMatrix) {
+    log("paint", "debug", "Run provided without lineMatrix, using identity fallback", {
+      text: run.text.slice(0, 32),
+      fontFamily: run.fontFamily,
+    });
+  }
+  const offsetPx = transformer.pageOffsetPx;
+
+  // Normalize to page origin (top-left), removing any page offset.
+  const local: Matrix = {
+    a: base.a,
+    b: base.b,
+    c: base.c,
+    d: base.d,
+    e: base.e,
+    f: base.f - offsetPx,
+  };
+
+  const hasLinear =
+    Math.abs(local.a - 1) > 1e-6 ||
+    Math.abs(local.b) > 1e-6 ||
+    Math.abs(local.c) > 1e-6 ||
+    Math.abs(local.d - 1) > 1e-6;
+
+  // Fast path: no skew/rotate/scale -> just convert translation.
+  if (!hasLinear) {
+    return {
+      a: 1, b: 0, c: 0, d: 1,
+      e: transformer.convertPxToPt(local.e),
+      f: transformer.pageHeightPt - transformer.convertPxToPt(local.f),
+    };
+  }
+
+  // Full path: map entire matrix from CSS (y-down) to PDF (y-up), then shift to bottom-left origin.
+  const pdfPx = svgMatrixToPdf(local) ?? { a: 1, b: 0, c: 0, d: 1, e: local.e, f: local.f };
+  return {
+    a: pdfPx.a,
+    b: pdfPx.b,
+    c: pdfPx.c,
+    d: pdfPx.d,
+    e: transformer.convertPxToPt(pdfPx.e),
+    f: transformer.convertPxToPt(pdfPx.f + transformer.pageHeightPx),
+  };
+}
+
+function computeGlyphRunFromText(
+  metrics: NonNullable<FontResource["metrics"]>,
+  text: string,
+  fontSize: number,
+  letterSpacing: number,
+  css: { family?: string; weight: number; style: "normal" | "italic" },
+): GlyphRun {
+  const glyphIds: number[] = [];
+  const positions: { x: number; y: number }[] = [];
+  const unitsPerEm = metrics.metrics.unitsPerEm;
+  let x = 0;
+
+  for (let i = 0; i < text.length; i++) {
+    const cp = text.codePointAt(i)!;
+    const gid = metrics.cmap.getGlyphId(cp);
+    glyphIds.push(gid);
+    positions.push({ x, y: 0 });
+    const advanceWidth = metrics.glyphMetrics.get(gid)?.advanceWidth ?? 0;
+    const advancePx = (advanceWidth / unitsPerEm) * fontSize + letterSpacing;
+    x += advancePx;
+    if (cp > 0xffff) i++;
+  }
+
+  const unifiedFont: UnifiedFont = {
+    metrics: {
+      metrics: metrics.metrics,
+      glyphMetrics: metrics.glyphMetrics,
+      cmap: metrics.cmap,
+      headBBox: metrics.headBBox,
+    },
+    program: {
+      sourceFormat: "ttf",
+      unitsPerEm: metrics.metrics.unitsPerEm,
+      glyphCount: metrics.glyphMetrics.size,
+      getGlyphOutline: metrics.getGlyphOutline,
+    },
+    css: {
+      family: css.family ?? "",
+      weight: css.weight,
+      style: css.style,
+    },
+  };
+
+  return {
+    font: unifiedFont,
+    glyphIds,
+    positions,
+    text,
+    fontSize,
+    width: x,
+  };
+}

package/src/pdf/renderers/text-shadow-renderer.ts

@@ -0,0 +1,300 @@
+import type { Run, TextMatrix } from "../types.js";
+import type { UnifiedFont } from "../../fonts/types.js";
+import type { FontRegistry, FontResource } from "../font/font-registry.js";
+import type { ImageRenderer } from "./image-renderer.js";
+import type { GraphicsStateManager } from "./graphics-state-manager.js";
+import { CoordinateTransformer } from "../utils/coordinate-transformer.js";
+import { getGlyphMask } from "../font/glyph-cache.js";
+import { blurAlpha } from "../font/blur.js";
+import { fillColorCommand, formatNumber, normalizeChannel } from "./text-renderer-utils.js";
+
+export interface TextShadowRenderContext {
+  run: Run;
+  font: FontResource;
+  encoded: string;
+  Tm: TextMatrix;
+  fontSizePt: number;
+  fontSizePx: number;
+  wordSpacingPt: number;
+  appliedWordSpacing: boolean;
+  fontResourceName?: string;
+}
+
+export class TextShadowRenderer {
+  private readonly runShadowCache = new Map<string, { alias: string; image: any }>();
+
+  constructor(
+    private readonly coordinateTransformer: CoordinateTransformer,
+    private readonly fontRegistry: FontRegistry,
+    private readonly imageRenderer?: ImageRenderer,
+    private readonly graphicsStateManager?: GraphicsStateManager,
+  ) {}
+
+  async render(context: TextShadowRenderContext): Promise<string[]> {
+    const commands: string[] = [];
+    const { run, font, encoded, Tm, fontSizePt, fontSizePx, wordSpacingPt, appliedWordSpacing, fontResourceName } = context;
+    if (!run.textShadows || run.textShadows.length === 0) {
+      return commands;
+    }
+
+    const needsRaster = run.textShadows.some(sh => (sh.blur ?? 0) > 0 || (sh.color && sh.color.a !== undefined && sh.color.a < 1));
+
+    // Prefer glyph-run supplied metrics (add outline hook) and fall back to embedder lookup.
+    const glyphMetrics = run.glyphs ? mergeMetricsWithOutline(run.glyphs.font) : null;
+    const embedder = this.fontRegistry.getEmbedder ? this.fontRegistry.getEmbedder() : undefined;
+    const faceMetrics = glyphMetrics ?? (embedder ? embedder.getMetrics((font as any).baseFont) : null);
+
+    const wordSpacingCmd = appliedWordSpacing ? `${formatNumber(wordSpacingPt)} Tw` : undefined;
+    const resetWordSpacingCmd = appliedWordSpacing ? "0 Tw" : undefined;
+    const fontName = fontResourceName ?? font.resourceName;
+
+    if (this.imageRenderer && needsRaster) {
+      if (run.glyphs && faceMetrics) {
+        try {
+          const pages = (await import("../font/glyph-atlas.js")).globalGlyphAtlas.getPages();
+          if (pages && pages.length > 0) {
+            this.imageRenderer.registerAtlasPages(pages);
+          }
+        } catch {
+          // ignore
+        }
+
+        const supersample = 4;
+        const glyphMasks: Array<{ mask: any; pos: { x: number; y: number } }> = [];
+        for (let gi = 0; gi < run.glyphs.glyphIds.length; gi++) {
+          const gid = run.glyphs.glyphIds[gi];
+          const pos = run.glyphs.positions[gi] ?? { x: 0, y: 0 };
+          try {
+            const gm = getGlyphMask(faceMetrics as any, gid, fontSizePx, supersample, 0);
+            if (!gm) continue;
+            glyphMasks.push({ mask: gm, pos });
+          } catch {
+            // ignore individual glyph failures
+          }
+        }
+
+        if (glyphMasks.length > 0) {
+          let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+          const maxBlurPx = run.textShadows.reduce((acc, sh) => Math.max(acc, Math.max(0, sh?.blur ?? 0)), 0);
+          for (const item of glyphMasks) {
+            const { mask, pos } = item;
+            const maskOffsetX = mask.offsetX ?? 0;
+            const maskOffsetY = mask.offsetY ?? 0;
+            const gx0 = pos.x + maskOffsetX;
+            const gy0 = pos.y + maskOffsetY;
+            const gx1 = gx0 + mask.width;
+            const gy1 = gy0 + mask.height;
+            if (gx0 < minX) minX = gx0;
+            if (gy0 < minY) minY = gy0;
+            if (gx1 > maxX) maxX = gx1;
+            if (gy1 > maxY) maxY = gy1;
+          }
+          // Pad the bounding box to leave room for blur bleed.
+          const bleedPad = Math.ceil(maxBlurPx * 2);
+          minX = Math.floor(minX - bleedPad);
+          minY = Math.floor(minY - bleedPad);
+          maxX = Math.ceil(maxX + bleedPad);
+          maxY = Math.ceil(maxY + bleedPad);
+
+          const combinedW = Math.max(0, maxX - minX);
+          const combinedH = Math.max(0, maxY - minY);
+          if (combinedW > 0 && combinedH > 0) {
+            const combinedAlpha = new Uint8Array(combinedW * combinedH);
+            for (const item of glyphMasks) {
+              const { mask, pos } = item;
+              const maskOffsetX = mask.offsetX ?? 0;
+              const maskOffsetY = mask.offsetY ?? 0;
+              const ox = Math.round(pos.x + maskOffsetX - minX);
+              const oy = Math.round(pos.y + maskOffsetY - minY);
+              for (let yy = 0; yy < mask.height; yy++) {
+                const dstRow = oy + yy;
+                if (dstRow < 0 || dstRow >= combinedH) continue;
+                const srcRow = yy;
+                const dstBase = dstRow * combinedW;
+                const srcBase = srcRow * mask.width;
+                for (let xx = 0; xx < mask.width; xx++) {
+                  const dstIdx = dstBase + ox + xx;
+                  if (dstIdx < 0 || dstIdx >= combinedAlpha.length) continue;
+                  const a = mask.data[srcBase + xx] || 0;
+                  const summed = combinedAlpha[dstIdx] + a;
+                  combinedAlpha[dstIdx] = summed > 255 ? 255 : summed;
+                }
+              }
+            }
+
+            for (const sh of run.textShadows) {
+              if (!sh || !sh.color) {
+                continue;
+              }
+              const blurPx = Math.max(0, sh.blur ?? 0);
+              const clampedCombined = combinedAlpha instanceof Uint8ClampedArray ? combinedAlpha : new Uint8ClampedArray(combinedAlpha);
+              const rawAlphaBuf = blurPx > 0 ? blurAlpha(clampedCombined, combinedW, combinedH, blurPx) : clampedCombined;
+              const alphaBuf = rawAlphaBuf instanceof Uint8ClampedArray ? rawAlphaBuf : new Uint8ClampedArray(rawAlphaBuf);
+
+              const r8 = Math.round(normalizeChannel(sh.color.r) * 255);
+              const g8 = Math.round(normalizeChannel(sh.color.g) * 255);
+              const b8 = Math.round(normalizeChannel(sh.color.b) * 255);
+              const shadowAlpha = sh.color.a ?? 1;
+
+              const cacheKey = `${run.text}|${(font as any).baseFont}|size:${fontSizePx}|blur:${Math.round(blurPx)}|color:${r8},${g8},${b8},${shadowAlpha}|ss:${supersample}`;
+              let resAlias: string | undefined;
+              const cached = this.runShadowCache.get(cacheKey);
+              if (cached) {
+                resAlias = cached.alias;
+              } else {
+                const rgba = new Uint8Array(combinedW * combinedH * 4);
+                for (let i = 0, j = 0; i < alphaBuf.length; i++, j += 4) {
+                  rgba[j] = r8;
+                  rgba[j + 1] = g8;
+                  rgba[j + 2] = b8;
+                  rgba[j + 3] = Math.round(alphaBuf[i] * shadowAlpha);
+                }
+                const img: any = {
+                  src: `internal:shadow:run:${(font as any).resourceName}:${Math.round(Math.random() * 1e9)}`,
+                  width: combinedW,
+                  height: combinedH,
+                  format: "png",
+                  channels: 4,
+                  bitsPerComponent: 8,
+                  data: rgba.buffer,
+                };
+                const res = this.imageRenderer.registerResource(img);
+                resAlias = res.alias;
+                this.runShadowCache.set(cacheKey, { alias: resAlias, image: img });
+              }
+              const offsetX = sh.offsetX ?? 0;
+              const offsetY = sh.offsetY ?? 0;
+              const xPx = Tm.e + offsetX + minX;
+              const yPxTop = Tm.f + offsetY + minY;
+              const widthPt = this.coordinateTransformer.convertPxToPt(combinedW);
+              const heightPt = this.coordinateTransformer.convertPxToPt(combinedH);
+              const xPt = this.coordinateTransformer.convertPxToPt(xPx);
+              const localYTop = yPxTop - this.coordinateTransformer.pageOffsetPx;
+              const yPt = this.coordinateTransformer.pageHeightPt - this.coordinateTransformer.convertPxToPt(localYTop + combinedH);
+
+              commands.push(
+                "q",
+                `${formatNumber(widthPt)} 0 0 ${formatNumber(heightPt)} ${formatNumber(xPt)} ${formatNumber(yPt)} cm`,
+                `/${resAlias} Do`,
+                "Q",
+              );
+            }
+          }
+        }
+
+        // If we failed to build any glyph masks (e.g., missing outlines), fall back to vector shadows.
+        if (glyphMasks.length === 0) {
+          this.appendVectorShadowLayers(commands, run, font, encoded, Tm, fontSizePt, fontName, wordSpacingCmd, resetWordSpacingCmd);
+        }
+      } else {
+        if (needsRaster && this.imageRenderer) {
+          try {
+            for (const sh of run.textShadows) {
+              if (!sh || !sh.color) continue;
+              const offsetX = sh.offsetX ?? 0;
+              const offsetY = sh.offsetY ?? 0;
+              const blurPx = Math.max(0, sh.blur ?? 0);
+              const baseAlpha = sh.color.a ?? 1;
+
+              const samples: { dx: number; dy: number; weight: number }[] = [];
+              if (blurPx <= 1) {
+                samples.push({ dx: 0, dy: 0, weight: 1 });
+              } else {
+                const centerW = 0.38;
+                const orthoW = 0.12;
+                const diagW = (1 - (centerW + 4 * orthoW)) / 4;
+                const radius = blurPx / 2;
+                samples.push({ dx: 0, dy: 0, weight: centerW });
+                samples.push({ dx: -radius, dy: 0, weight: orthoW });
+                samples.push({ dx: radius, dy: 0, weight: orthoW });
+                samples.push({ dx: 0, dy: -radius, weight: orthoW });
+                samples.push({ dx: 0, dy: radius, weight: orthoW });
+                samples.push({ dx: -radius, dy: -radius, weight: diagW });
+                samples.push({ dx: radius, dy: -radius, weight: diagW });
+                samples.push({ dx: -radius, dy: radius, weight: diagW });
+                samples.push({ dx: radius, dy: radius, weight: diagW });
+              }
+
+              for (const s of samples) {
+                const sx = s.dx;
+                const sy = s.dy;
+                const sampleAlpha = baseAlpha * s.weight;
+                const sampleColor = { r: sh.color.r, g: sh.color.g, b: sh.color.b, a: sampleAlpha };
+
+                const shadowX = this.coordinateTransformer.convertPxToPt(Tm.e + offsetX + sx);
+                const shadowLocalBaseline = Tm.f - this.coordinateTransformer.pageOffsetPx + offsetY + sy;
+                const shadowYPt = this.coordinateTransformer.pageHeightPt - this.coordinateTransformer.convertPxToPt(shadowLocalBaseline);
+
+                const shadowSequence: string[] = ["q", fillColorCommand(sampleColor, this.graphicsStateManager), "BT"];
+                if (wordSpacingCmd) shadowSequence.push(wordSpacingCmd);
+                shadowSequence.push(
+                  `/${fontName} ${formatNumber(fontSizePt)} Tf`,
+                  `${formatNumber(Tm.a)} ${formatNumber(Tm.b)} ${formatNumber(Tm.c)} ${formatNumber(Tm.d)} ${formatNumber(shadowX)} ${formatNumber(shadowYPt)} Tm`,
+                  `(${encoded}) Tj`,
+                );
+                if (resetWordSpacingCmd) shadowSequence.push(resetWordSpacingCmd);
+                shadowSequence.push("ET", "Q");
+                commands.push(...shadowSequence);
+              }
+            }
+          } catch {
+            this.appendVectorShadowLayers(commands, run, font, encoded, Tm, fontSizePt, fontName, wordSpacingCmd, resetWordSpacingCmd);
+          }
+        } else {
+          this.appendVectorShadowLayers(commands, run, font, encoded, Tm, fontSizePt, fontName, wordSpacingCmd, resetWordSpacingCmd);
+        }
+      }
+    } else {
+      this.appendVectorShadowLayers(commands, run, font, encoded, Tm, fontSizePt, fontName, wordSpacingCmd, resetWordSpacingCmd);
+    }
+
+    return commands;
+  }
+
+  private appendVectorShadowLayers(
+    commands: string[],
+    run: Run,
+    font: FontResource,
+    encoded: string,
+    Tm: TextMatrix,
+    fontSizePt: number,
+    fontName: string,
+    wordSpacingCmd?: string,
+    resetWordSpacingCmd?: string,
+  ): void {
+    const shadows = run.textShadows ?? [];
+    for (const sh of shadows) {
+      if (!sh || !sh.color) {
+        continue;
+      }
+      const shadowX = this.coordinateTransformer.convertPxToPt(Tm.e + (sh.offsetX ?? 0));
+      const shadowLocalBaseline = Tm.f - this.coordinateTransformer.pageOffsetPx + (sh.offsetY ?? 0);
+      const shadowYPt = this.coordinateTransformer.pageHeightPt - this.coordinateTransformer.convertPxToPt(shadowLocalBaseline);
+
+      const shadowSequence: string[] = ["q", fillColorCommand(sh.color, this.graphicsStateManager), "BT"];
+      if (wordSpacingCmd) shadowSequence.push(wordSpacingCmd);
+      shadowSequence.push(
+        `/${fontName} ${formatNumber(fontSizePt)} Tf`,
+        `${formatNumber(Tm.a)} ${formatNumber(Tm.b)} ${formatNumber(Tm.c)} ${formatNumber(Tm.d)} ${formatNumber(shadowX)} ${formatNumber(shadowYPt)} Tm`,
+        `(${encoded}) Tj`,
+      );
+      if (resetWordSpacingCmd) shadowSequence.push(resetWordSpacingCmd);
+      shadowSequence.push("ET", "Q");
+      commands.push(...shadowSequence);
+    }
+  }
+}
+
+// Merge UnifiedFont metrics with its outline provider so glyph rasterization can work.
+function mergeMetricsWithOutline(font: UnifiedFont | undefined | null): any | null {
+  if (!font?.metrics || !font.program?.getGlyphOutline) {
+    return null;
+  }
+  return {
+    metrics: font.metrics.metrics,
+    glyphMetrics: font.metrics.glyphMetrics,
+    cmap: font.metrics.cmap,
+    headBBox: font.metrics.headBBox,
+    getGlyphOutline: font.program.getGlyphOutline,
+  };
+}