'use strict';

import {Parser} from 'htmlparser2';

import {PassThrough} from 'stream';

const PDFDocument = require('pdfkit');

interface InlineState {

bold: boolean;

italic: boolean;

underline: boolean;

strike: boolean;

link?: string;

fontSize?: number;

align?: 'left' | 'center' | 'right' | 'justify';

mono?: boolean;

}

const parseAlign = (style: string | undefined): InlineState['align'] | undefined => {

if (!style) return undefined;

const m = /text-align\s*:\s*(left|center|right|justify)/i.exec(style);

return m ? (m[1].toLowerCase() as InlineState['align']) : undefined;

};

const HEADING_SIZES: Record<string, number> = {

h1: 24, h2: 20, h3: 16, h4: 14, h5: 12, h6: 11,

};

// Tags whose text content must never appear in the rendered PDF (CSS,

// scripts, document metadata). The walker maintains a depth counter so that

// nested elements inside one of these are ignored too.

const SKIP_TAGS = new Set(['head', 'style', 'script', 'title', 'meta', 'link', 'noscript']);

const decodeDataUri = (src: string): Buffer | null => {

const m = /^data:[^;,]+;base64,(.+)$/i.exec(src);

if (!m) return null;

try {

return Buffer.from(m[1], 'base64');

} catch {

return null;

}

};

export const htmlToPdfBuffer = (html: string): Promise<Buffer> =>

new Promise((resolve, reject) => {

// compress:false keeps the content stream uncompressed. Pads are small

// enough that the size cost is negligible, and it lets ops greppable PDFs

// out of the box for accessibility / search-engine indexers that don't

// FlateDecode.

const doc = new PDFDocument({margin: 50, compress: false});

const stream = new PassThrough();

const chunks: Buffer[] = [];

stream.on('data', (c: Buffer) => chunks.push(c));

stream.on('end', () => resolve(Buffer.concat(chunks)));

stream.on('error', reject);

doc.pipe(stream);

const styleStack: InlineState[] = [{

bold: false, italic: false, underline: false, strike: false,

}];

const listType: ('ul' | 'ol' | null)[] = [];

const listIndex: number[] = [];

let pendingNewline = false;

let skipDepth = 0;

const top = () => styleStack[styleStack.length - 1];

const applyFont = () => {

const s = top();

let variant: string;

if (s.mono) {

variant =

s.bold && s.italic ? 'Courier-BoldOblique' :

s.bold ? 'Courier-Bold' :

s.italic ? 'Courier-Oblique' :

'Courier';

} else {

variant =

s.bold && s.italic ? 'Helvetica-BoldOblique' :

s.bold ? 'Helvetica-Bold' :

s.italic ? 'Helvetica-Oblique' :

'Helvetica';

}

doc.font(variant);

doc.fontSize(s.fontSize || 11);

};

// Track whether the current run started with an alignment override so

// we apply `align` exactly once per pdfkit text() call (pdfkit uses the

// align option of the first call in a continued run for the whole line).

let runStartedAligned = false;

const writeText = (raw: string) => {

if (!raw) return;

if (pendingNewline) {

doc.moveDown(0.5);

pendingNewline = false;

}

const s = top();

applyFont();

const opts: any = {continued: true};

if (s.underline) opts.underline = true;

if (s.strike) opts.strike = true;

if (s.link) opts.link = s.link;

if (s.align && !runStartedAligned) {

opts.align = s.align;

runStartedAligned = true;

}

doc.text(raw, opts);

};

// End the current `continued: true` text run. pdfkit's `text('', false)`

// closes the run but does NOT advance the cursor — subsequent text would

// overlay at the same y. Use `breakLine` whenever a true newline is

// intended (br, end-of-block, list items).

const flushLine = () => {

doc.text('', {continued: false});

runStartedAligned = false;

};

const breakLine = () => {

flushLine();

doc.moveDown(1);

};

const parser = new Parser({

onopentag(name, attribs) {

if (SKIP_TAGS.has(name)) skipDepth += 1;

if (skipDepth > 0) {

styleStack.push({...top()});

return;

}

const cur = top();

const next: InlineState = {...cur};

switch (name) {

case 'b': case 'strong': next.bold = true; break;

case 'i': case 'em': next.italic = true; break;

case 'u': next.underline = true; break;

case 's': case 'strike': case 'del': next.strike = true; break;

case 'a': next.link = attribs.href; next.underline = true; break;

case 'code': case 'tt': case 'kbd': case 'samp': {

next.mono = true;

// ep_headings2 uses <code style='text-align:...'> as a block-

// styled "code" line, so read the alignment off the opening

// tag too. parseAlign returns undefined when no text-align

// is set, so this is a no-op for inline <code> usage.

const a = parseAlign(attribs.style);

if (a) next.align = a;

break;

}

case 'pre': {

next.mono = true;

const a = parseAlign(attribs.style);

if (a) next.align = a;

if (!pendingNewline) breakLine();

break;

}

case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6': {

next.fontSize = HEADING_SIZES[name];

next.bold = true;

const a = parseAlign(attribs.style);

if (a) next.align = a;

if (!pendingNewline) breakLine();

break;

}

case 'p': case 'div': {

const a = parseAlign(attribs.style);

if (a) next.align = a;

if (!pendingNewline) breakLine();

break;

}

case 'ul': case 'ol':

listType.push(name as 'ul' | 'ol');

listIndex.push(0);

breakLine();

break;

case 'li': {

breakLine();

const t = listType[listType.length - 1] || 'ul';

if (t === 'ol') listIndex[listIndex.length - 1] += 1;

const prefix = t === 'ul'

? '• '

: `${listIndex[listIndex.length - 1]}. `;

const indent = ' '.repeat(Math.max(0, listType.length - 1));

applyFont();

doc.text(`${indent}${prefix}`, {continued: true});

break;

}

case 'br':

breakLine();

break;

case 'img': {

const buf = decodeDataUri(attribs.src || '');

if (buf) {

flushLine();

try { doc.image(buf, {fit: [400, 300]}); } catch { /* skip bad image */ }

}

break;

}

}

styleStack.push(next);

},

ontext(text) {

if (skipDepth > 0) return;

// Collapse consecutive whitespace to a single space, the way an

// HTML renderer would. Without this, literal newlines and tabs in

// pretty-printed source HTML show up as runs of " " in the PDF.

const collapsed = text.replace(/[\s ]+/g, ' ');

if (collapsed === ' ') return; // pure-whitespace runs are dropped

writeText(collapsed);

},

onclosetag(name) {

if (skipDepth > 0) {

if (SKIP_TAGS.has(name)) skipDepth -= 1;

styleStack.pop();

if (styleStack.length === 0) {

styleStack.push({bold: false, italic: false, underline: false, strike: false});

}

return;

}

switch (name) {

case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':

case 'p': case 'div': case 'pre':

breakLine();

pendingNewline = true;

break;

case 'li':

flushLine();

break;

case 'ul': case 'ol':

listType.pop();

listIndex.pop();

doc.moveDown(0.3);

break;

}

styleStack.pop();

if (styleStack.length === 0) {

styleStack.push({bold: false, italic: false, underline: false, strike: false});

}

},

}, {decodeEntities: true, lowerCaseTags: true});

parser.write(html);

parser.end();

flushLine();

doc.end();

});