@adnsistemas/pdf-lib 1.18.0

package/src/core/embedders/StandardFontEmbedder.ts

@@ -0,0 +1,130 @@
+import {
+  Encodings,
+  Font,
+  FontNames,
+  EncodingType,
+} from '@pdf-lib/standard-fonts';
+
+import PDFHexString from 'src/core/objects/PDFHexString';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFContext from 'src/core/PDFContext';
+import { toCodePoint, toHexString } from 'src/utils';
+
+export interface Glyph {
+  code: number;
+  name: string;
+}
+
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/foliojs/pdfkit/blob/f91bdd61c164a72ea06be1a43dc0a412afc3925f/lib/font/afm.coffee
+ */
+class StandardFontEmbedder {
+  static for = (fontName: FontNames, customName?: string) =>
+    new StandardFontEmbedder(fontName, customName);
+
+  readonly font: Font;
+  readonly encoding: EncodingType;
+  readonly fontName: string;
+  readonly customName: string | undefined;
+
+  private constructor(fontName: FontNames, customName?: string) {
+    // prettier-ignore
+    this.encoding = (
+        fontName === FontNames.ZapfDingbats ? Encodings.ZapfDingbats
+      : fontName === FontNames.Symbol       ? Encodings.Symbol
+      : Encodings.WinAnsi
+    );
+    this.font = Font.load(fontName);
+    this.fontName = this.font.FontName;
+    this.customName = customName;
+  }
+
+  /**
+   * Encode the JavaScript string into this font. (JavaScript encodes strings in
+   * Unicode, but standard fonts use either WinAnsi, ZapfDingbats, or Symbol
+   * encodings)
+   */
+  encodeText(text: string): PDFHexString {
+    const glyphs = this.encodeTextAsGlyphs(text);
+    const hexCodes = new Array(glyphs.length);
+    for (let idx = 0, len = glyphs.length; idx < len; idx++) {
+      hexCodes[idx] = toHexString(glyphs[idx].code);
+    }
+    return PDFHexString.of(hexCodes.join(''));
+  }
+
+  widthOfTextAtSize(text: string, size: number): number {
+    const glyphs = this.encodeTextAsGlyphs(text);
+    let totalWidth = 0;
+
+    for (let idx = 0, len = glyphs.length; idx < len; idx++) {
+      const left = glyphs[idx].name;
+      const right = (glyphs[idx + 1] || {}).name;
+      const kernAmount = this.font.getXAxisKerningForPair(left, right) || 0;
+      totalWidth += this.widthOfGlyph(left) + kernAmount;
+    }
+
+    const scale = size / 1000;
+    return totalWidth * scale;
+  }
+
+  heightOfFontAtSize(
+    size: number,
+    options: { descender?: boolean } = {},
+  ): number {
+    const { descender = true } = options;
+
+    const { Ascender, Descender, FontBBox } = this.font;
+    const yTop = Ascender || FontBBox[3];
+    const yBottom = Descender || FontBBox[1];
+
+    let height = yTop - yBottom;
+    if (!descender) height += Descender || 0;
+
+    return (height / 1000) * size;
+  }
+
+  sizeOfFontAtHeight(height: number): number {
+    const { Ascender, Descender, FontBBox } = this.font;
+    const yTop = Ascender || FontBBox[3];
+    const yBottom = Descender || FontBBox[1];
+    return (1000 * height) / (yTop - yBottom);
+  }
+
+  embedIntoContext(context: PDFContext, ref?: PDFRef): PDFRef {
+    const fontDict = context.obj({
+      Type: 'Font',
+      Subtype: 'Type1',
+      BaseFont: this.customName || this.fontName,
+
+      Encoding:
+        this.encoding === Encodings.WinAnsi ? 'WinAnsiEncoding' : undefined,
+    });
+
+    if (ref) {
+      context.assign(ref, fontDict);
+      return ref;
+    } else {
+      return context.register(fontDict);
+    }
+  }
+
+  private widthOfGlyph(glyphName: string): number {
+    // Default to 250 if font doesn't specify a width
+    return this.font.getWidthOfGlyph(glyphName) || 250;
+  }
+
+  private encodeTextAsGlyphs(text: string): Glyph[] {
+    const codePoints = Array.from(text);
+    const glyphs: Glyph[] = new Array(codePoints.length);
+    for (let idx = 0, len = codePoints.length; idx < len; idx++) {
+      const codePoint = toCodePoint(codePoints[idx])!;
+      glyphs[idx] = this.encoding.encodeUnicodeCodePoint(codePoint);
+    }
+    return glyphs;
+  }
+}
+
+export default StandardFontEmbedder;

package/src/core/errors.ts

@@ -0,0 +1,221 @@
+// tslint:disable: max-classes-per-file
+import PDFObject from 'src/core/objects/PDFObject';
+import { arrayAsString } from 'src/utils';
+
+export class MethodNotImplementedError extends Error {
+  constructor(className: string, methodName: string) {
+    const msg = `Method ${className}.${methodName}() not implemented`;
+    super(msg);
+  }
+}
+
+export class PrivateConstructorError extends Error {
+  constructor(className: string) {
+    const msg = `Cannot construct ${className} - it has a private constructor`;
+    super(msg);
+  }
+}
+
+export class UnexpectedObjectTypeError extends Error {
+  constructor(expected: any | any[], actual: any) {
+    const name = (t: any) => t?.name ?? t?.constructor?.name;
+
+    const expectedTypes = Array.isArray(expected)
+      ? expected.map(name)
+      : [name(expected)];
+
+    const msg =
+      `Expected instance of ${expectedTypes.join(' or ')}, ` +
+      `but got instance of ${actual ? name(actual) : actual}`;
+
+    super(msg);
+  }
+}
+
+export class UnsupportedEncodingError extends Error {
+  constructor(encoding: string) {
+    const msg = `${encoding} stream encoding not supported`;
+    super(msg);
+  }
+}
+
+export class ReparseError extends Error {
+  constructor(className: string, methodName: string) {
+    const msg = `Cannot call ${className}.${methodName}() more than once`;
+    super(msg);
+  }
+}
+
+export class MissingCatalogError extends Error {
+  constructor(ref?: PDFObject) {
+    const msg = `Missing catalog (ref=${ref})`;
+    super(msg);
+  }
+}
+
+export class MissingPageContentsEmbeddingError extends Error {
+  constructor() {
+    const msg = `Can't embed page with missing Contents`;
+    super(msg);
+  }
+}
+
+export class UnrecognizedStreamTypeError extends Error {
+  constructor(stream: any) {
+    const streamType = stream?.contructor?.name ?? stream?.name ?? stream;
+    const msg = `Unrecognized stream type: ${streamType}`;
+    super(msg);
+  }
+}
+
+export class PageEmbeddingMismatchedContextError extends Error {
+  constructor() {
+    const msg = `Found mismatched contexts while embedding pages. All pages in the array passed to \`PDFDocument.embedPages()\` must be from the same document.`;
+    super(msg);
+  }
+}
+
+export class PDFArrayIsNotRectangleError extends Error {
+  constructor(size: number) {
+    const msg = `Attempted to convert PDFArray with ${size} elements to rectangle, but must have exactly 4 elements.`;
+    super(msg);
+  }
+}
+
+export class InvalidPDFDateStringError extends Error {
+  constructor(value: string) {
+    const msg = `Attempted to convert "${value}" to a date, but it does not match the PDF date string format.`;
+    super(msg);
+  }
+}
+
+export class InvalidTargetIndexError extends Error {
+  constructor(targetIndex: number, Count: number) {
+    const msg = `Invalid targetIndex specified: targetIndex=${targetIndex} must be less than Count=${Count}`;
+    super(msg);
+  }
+}
+
+export class CorruptPageTreeError extends Error {
+  constructor(targetIndex: number, operation: string) {
+    const msg = `Failed to ${operation} at targetIndex=${targetIndex} due to corrupt page tree: It is likely that one or more 'Count' entries are invalid`;
+    super(msg);
+  }
+}
+
+export class IndexOutOfBoundsError extends Error {
+  constructor(index: number, min: number, max: number) {
+    const msg = `index should be at least ${min} and at most ${max}, but was actually ${index}`;
+    super(msg);
+  }
+}
+
+export class InvalidAcroFieldValueError extends Error {
+  constructor() {
+    const msg = `Attempted to set invalid field value`;
+    super(msg);
+  }
+}
+
+export class MultiSelectValueError extends Error {
+  constructor() {
+    const msg = `Attempted to select multiple values for single-select field`;
+    super(msg);
+  }
+}
+
+export class MissingDAEntryError extends Error {
+  constructor(fieldName: string) {
+    const msg = `No /DA (default appearance) entry found for field: ${fieldName}`;
+    super(msg);
+  }
+}
+
+export class MissingTfOperatorError extends Error {
+  constructor(fieldName: string) {
+    const msg = `No Tf operator found for DA of field: ${fieldName}`;
+    super(msg);
+  }
+}
+
+/***** Parser Errors ******/
+
+export interface Position {
+  line: number;
+  column: number;
+  offset: number;
+}
+
+export class NumberParsingError extends Error {
+  constructor(pos: Position, value: string) {
+    const msg =
+      `Failed to parse number ` +
+      `(line:${pos.line} col:${pos.column} offset=${pos.offset}): "${value}"`;
+    super(msg);
+  }
+}
+
+export class PDFParsingError extends Error {
+  constructor(pos: Position, details: string) {
+    const msg =
+      `Failed to parse PDF document ` +
+      `(line:${pos.line} col:${pos.column} offset=${pos.offset}): ${details}`;
+    super(msg);
+  }
+}
+
+export class NextByteAssertionError extends PDFParsingError {
+  constructor(pos: Position, expectedByte: number, actualByte: number) {
+    const msg = `Expected next byte to be ${expectedByte} but it was actually ${actualByte}`;
+    super(pos, msg);
+  }
+}
+
+export class PDFObjectParsingError extends PDFParsingError {
+  constructor(pos: Position, byte: number) {
+    const msg = `Failed to parse PDF object starting with the following byte: ${byte}`;
+    super(pos, msg);
+  }
+}
+
+export class PDFInvalidObjectParsingError extends PDFParsingError {
+  constructor(pos: Position) {
+    const msg = `Failed to parse invalid PDF object`;
+    super(pos, msg);
+  }
+}
+
+export class PDFStreamParsingError extends PDFParsingError {
+  constructor(pos: Position) {
+    const msg = `Failed to parse PDF stream`;
+    super(pos, msg);
+  }
+}
+
+export class UnbalancedParenthesisError extends PDFParsingError {
+  constructor(pos: Position) {
+    const msg = `Failed to parse PDF literal string due to unbalanced parenthesis`;
+    super(pos, msg);
+  }
+}
+
+export class StalledParserError extends PDFParsingError {
+  constructor(pos: Position) {
+    const msg = `Parser stalled`;
+    super(pos, msg);
+  }
+}
+
+export class MissingPDFHeaderError extends PDFParsingError {
+  constructor(pos: Position) {
+    const msg = `No PDF header found`;
+    super(pos, msg);
+  }
+}
+
+export class MissingKeywordError extends PDFParsingError {
+  constructor(pos: Position, keyword: number[]) {
+    const msg = `Did not find expected keyword '${arrayAsString(keyword)}'`;
+    super(pos, msg);
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,69 @@
+export * from 'src/core/errors';
+export { default as CharCodes } from 'src/core/syntax/CharCodes';
+
+export { default as PDFContext } from 'src/core/PDFContext';
+export { default as PDFObjectCopier } from 'src/core/PDFObjectCopier';
+export { default as PDFWriter } from 'src/core/writers/PDFWriter';
+export { default as PDFStreamWriter } from 'src/core/writers/PDFStreamWriter';
+
+export { default as PDFHeader } from 'src/core/document/PDFHeader';
+export { default as PDFTrailer } from 'src/core/document/PDFTrailer';
+export { default as PDFTrailerDict } from 'src/core/document/PDFTrailerDict';
+export { default as PDFCrossRefSection } from 'src/core/document/PDFCrossRefSection';
+
+export { default as StandardFontEmbedder } from 'src/core/embedders/StandardFontEmbedder';
+export { default as CustomFontEmbedder } from 'src/core/embedders/CustomFontEmbedder';
+export { default as CustomFontSubsetEmbedder } from 'src/core/embedders/CustomFontSubsetEmbedder';
+export {
+  default as FileEmbedder,
+  AFRelationship,
+} from 'src/core/embedders/FileEmbedder';
+export { default as JpegEmbedder } from 'src/core/embedders/JpegEmbedder';
+export { default as PngEmbedder } from 'src/core/embedders/PngEmbedder';
+export {
+  default as PDFPageEmbedder,
+  PageBoundingBox,
+} from 'src/core/embedders/PDFPageEmbedder';
+
+export {
+  default as ViewerPreferences,
+  NonFullScreenPageMode,
+  ReadingDirection,
+  PrintScaling,
+  Duplex,
+} from 'src/core/interactive/ViewerPreferences';
+
+export { default as PDFObject } from 'src/core/objects/PDFObject';
+export { default as PDFBool } from 'src/core/objects/PDFBool';
+export { default as PDFNumber } from 'src/core/objects/PDFNumber';
+export { default as PDFString } from 'src/core/objects/PDFString';
+export { default as PDFHexString } from 'src/core/objects/PDFHexString';
+export { default as PDFName } from 'src/core/objects/PDFName';
+export { default as PDFNull } from 'src/core/objects/PDFNull';
+export { default as PDFArray } from 'src/core/objects/PDFArray';
+export { default as PDFDict } from 'src/core/objects/PDFDict';
+export { default as PDFRef } from 'src/core/objects/PDFRef';
+export { default as PDFInvalidObject } from 'src/core/objects/PDFInvalidObject';
+export { default as PDFStream } from 'src/core/objects/PDFStream';
+export { default as PDFRawStream } from 'src/core/objects/PDFRawStream';
+
+export { default as PDFCatalog } from 'src/core/structures/PDFCatalog';
+export { default as PDFContentStream } from 'src/core/structures/PDFContentStream';
+export { default as PDFCrossRefStream } from 'src/core/structures/PDFCrossRefStream';
+export { default as PDFObjectStream } from 'src/core/structures/PDFObjectStream';
+export { default as PDFPageTree } from 'src/core/structures/PDFPageTree';
+export { default as PDFPageLeaf } from 'src/core/structures/PDFPageLeaf';
+export { default as PDFFlateStream } from 'src/core/structures/PDFFlateStream';
+
+export { default as PDFOperator } from 'src/core/operators/PDFOperator';
+export { default as PDFOperatorNames } from 'src/core/operators/PDFOperatorNames';
+
+export { default as PDFObjectParser } from 'src/core/parser/PDFObjectParser';
+export { default as PDFObjectStreamParser } from 'src/core/parser/PDFObjectStreamParser';
+export { default as PDFParser } from 'src/core/parser/PDFParser';
+export { default as PDFXRefStreamParser } from 'src/core/parser/PDFXRefStreamParser';
+
+export { decodePDFRawStream } from 'src/core/streams/decode';
+
+export * from 'src/core/annotation';
+export * from 'src/core/acroform';