@doccloak/core 0.12.1 → 0.14.0

package/dist/pdf/standard-metrics.js

@@ -0,0 +1,72 @@
+/**
+ * @doccloak/core/pdf - metrics of the standard 14 fonts (T209).
+ *
+ * Fonts that are not embedded and carry no /Widths (the standard 14 and their
+ * common aliases: Arial, Times New Roman, Courier New) get their advance
+ * widths from the AFM metrics vendored by @cantoo/pdf-lib.
+ */
+import { Font as AfmFont } from '@cantoo/pdf-lib/standard-fonts';
+const CACHE = new Map();
+function normalizeBaseFont(baseFont) {
+    return baseFont.replace(/^[A-Z]{6}\+/, '').replace(/[\s_]/g, '').toLowerCase();
+}
+/**
+ * Map a /BaseFont to a standard 14 font, or undefined. Handles the aliases
+ * from the PDF 1.7 implementation notes (Arial, TimesNewRoman, CourierNew)
+ * and the ",Bold" / "-BoldItalic" / "PS-BoldMT" style suffixes.
+ */
+export function standardFontFor(baseFont) {
+    const n = normalizeBaseFont(baseFont);
+    const bold = /bold|black|heavy|semibold|demibold/.test(n);
+    const italic = /italic|oblique/.test(n);
+    let family;
+    if (n.startsWith('courier'))
+        family = 'Courier';
+    else if (n.startsWith('helvetica') || n.startsWith('arial'))
+        family = 'Helvetica';
+    else if (n.startsWith('times'))
+        family = 'Times';
+    else if (n === 'symbol' || n.startsWith('symbol,') || n === 'symbolmt')
+        family = 'Symbol';
+    else if (n.startsWith('zapfdingbats') || n === 'dingbats')
+        family = 'ZapfDingbats';
+    if (!family)
+        return undefined;
+    if (family === 'Symbol' || family === 'ZapfDingbats')
+        return family;
+    if (family === 'Times') {
+        if (bold && italic)
+            return 'Times-BoldItalic';
+        if (bold)
+            return 'Times-Bold';
+        if (italic)
+            return 'Times-Italic';
+        return 'Times-Roman';
+    }
+    const suffix = bold && italic ? '-BoldOblique' : bold ? '-Bold' : italic ? '-Oblique' : '';
+    return `${family}${suffix}`;
+}
+export function loadStandardMetrics(name) {
+    let afm = CACHE.get(name);
+    if (!afm) {
+        afm = AfmFont.load(name);
+        CACHE.set(name, afm);
+    }
+    const font = afm;
+    const byName = new Map();
+    const builtin = new Array(256).fill(undefined);
+    for (const m of font.CharMetrics) {
+        byName.set(m.N, m.WX);
+        if (typeof m.C === 'number' && m.C >= 0 && m.C < 256)
+            builtin[m.C] = m.N;
+    }
+    return {
+        name,
+        widthOfGlyph: (g) => byName.get(g),
+        hasGlyph: (g) => byName.has(g),
+        builtinEncoding: () => builtin,
+        ascender: font.Ascender ?? 718,
+        descender: font.Descender ?? -207,
+        capHeight: font.CapHeight ?? 718,
+    };
+}

package/dist/pdf/surgery.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @doccloak/core/pdf - content-stream surgery (T213).
+ *
+ * Turns flat-text replacements into operator-level edits and rewrites the
+ * affected content streams:
+ *
+ * - the glyphs of a redacted span are cut out of their text-showing operator
+ *   (string operands are split at code boundaries; kerning numbers between
+ *   kept glyphs are preserved, numbers adjacent to removed glyphs are dropped);
+ * - the placeholder is written as a new show in the original font when that
+ *   font can encode it, else in the matched fallback face, sized by fit.ts;
+ * - every show after an edited one in the same positioning scope is
+ *   re-anchored with an absolute Tm computed from the ORIGINAL geometry, so
+ *   the implicit advance chain cannot shift (and the residual positions of
+ *   surviving glyphs cannot encode what was removed);
+ * - when the placeholder is wider than the gap even after shrinking, the rest
+ *   of the line (in the same stream) moves right by the overflow;
+ * - the line matrix is restored before the next relative positioning
+ *   operator, so later lines land exactly where they did.
+ *
+ * Operators that are not touched are copied byte-for-byte.
+ */
+import type { GlyphRun, PlaceholderFit } from './types.js';
+import type { LoadedFont } from './fonts.js';
+import type { StreamRecord, PdfModel } from './extract.js';
+import type { FitResult } from './fit.js';
+export interface Replacement {
+    start: number;
+    end: number;
+    replacement: string;
+}
+/** A placeholder resolved to concrete bytes in a concrete font resource. */
+export interface PlaceholderSpec {
+    text: string;
+    bytes: Uint8Array;
+    /** Resource name (in the stream's /Resources /Font) of the font to show it with. */
+    resourceName: string;
+    /** True when the original font is reused (no resource to add). */
+    originalFont: boolean;
+    fit: FitResult;
+    /** Codes shown in the original font (for ToUnicode scrubbing); empty for fallback fonts. */
+    codes: number[];
+    /**
+     * Negative when the placeholder is narrower than the gap: the text that
+     * follows in the same positioning chain moves left by this much (unscaled
+     * text space of the run) so no hole is left before the next word. Zero
+     * otherwise (overflow is handled line-wide through LineShift).
+     */
+    slack: number;
+}
+/** One contiguous glyph range of one run that a replacement covers. */
+export interface Segment {
+    run: GlyphRun;
+    /** Glyph index range [from, to). */
+    from: number;
+    to: number;
+    /** Set on the first segment of a replacement: the placeholder to show there. */
+    placeholder?: PlaceholderSpec;
+    replacementIndex: number;
+    /** True when this segment is the only one of its replacement (its codes are the complete value in one run). */
+    whole?: boolean;
+    /**
+     * Set on the segment where the replacement's gap ends: how far the glyphs
+     * after it in the same run move (unscaled text space of the run; negative
+     * closes the slack of a narrow placeholder, positive pushes an overflow).
+     */
+    shiftAfter?: number;
+}
+/** Key of a run inside a plan: stream key + operator index. */
+export declare function runKey(run: GlyphRun): string;
+/**
+ * Resolve a font for a placeholder: returns the encoded bytes with the
+ * original font, or asks the host for a fallback (which must already be
+ * embedded so its bytes are final).
+ */
+export interface PlaceholderResolver {
+    (font: LoadedFont, text: string, streamKey: string): Promise<{
+        bytes: Uint8Array;
+        widthPerEm: number;
+        resourceName: string;
+        originalFont: boolean;
+        codes: number[];
+    }>;
+}
+/**
+ * Map flat-text replacements to per-run glyph segments. Runs must be in
+ * flat-text order (as the extractor produced them). Oracle runs (raster-only
+ * pages) are returned as segments too; the caller routes them to the
+ * rasterizer.
+ */
+export declare function segmentsFor(runs: GlyphRun[], replacements: Replacement[]): Segment[];
+/** User units per unscaled text-space unit along the baseline of a run. */
+export declare function unitScale(run: GlyphRun): number;
+export interface Plan {
+    /** Segments grouped by stream key; each stream's segments sorted by (opIndex, from). */
+    byStream: Map<string, Segment[]>;
+    /** Runs that move as a whole (run key -> shift in user units along their baseline). */
+    shiftedRuns: Map<string, number>;
+    /** Fallback resource names needed per stream key. */
+    resourcesNeeded: Map<string, Set<string>>;
+    shiftedLines: number;
+    warnings: string[];
+}
+/**
+ * Decide, for every replacement, where the placeholder goes and how it is
+ * fitted. The first segment (flat-text order) carries the placeholder; other
+ * segments are excised. The gap is the width of every segment of the same
+ * replacement that sits on the same line as the first, so a name split over
+ * two shows on one line gets the whole width.
+ */
+export declare function planEdits(model: PdfModel, allRuns: GlyphRun[], segments: Segment[], replacements: Replacement[], resolve: PlaceholderResolver, fitPolicy?: PlaceholderFit): Promise<Plan>;
+export interface RewriteResult {
+    bytes: Uint8Array;
+    /** Codes still shown per font key after the rewrite (for ToUnicode scrubbing). */
+    usedCodes: Map<string, Set<number>>;
+    /** Original code sequences removed (per font key), for the verifier's byte scan. */
+    removedSequences: Array<{
+        fontKey: string;
+        bytes: Uint8Array;
+        codeLength: number;
+    }>;
+    /** Fonts whose glyphs were removed. */
+    editedFonts: Set<string>;
+    edits: number;
+}
+/**
+ * Rewrite one stream. `runsByOp` gives the GlyphRun of every text-showing
+ * operator (first instance for shared XObjects). `segments` are the edits in
+ * this stream. Every unaffected operator is copied verbatim.
+ */
+export declare function rewriteStream(model: PdfModel, stream: StreamRecord, runsByOp: Map<number, GlyphRun>, segments: Segment[], shiftedRuns: Map<string, number>): RewriteResult;