@pdfme/pdf-lib 0.0.0

package/src/core/embedders/FileEmbedder.ts

@@ -0,0 +1,77 @@
+import PDFString from '../objects/PDFString';
+import PDFHexString from '../objects/PDFHexString';
+import PDFContext from '../PDFContext';
+import PDFRef from '../objects/PDFRef';
+
+/**
+ * From the PDF-A3 specification, section **3.1. Requirements - General**.
+ * See:
+ * * https://www.pdfa.org/wp-content/uploads/2018/10/PDF20_AN002-AF.pdf
+ */
+export enum AFRelationship {
+  Source = 'Source',
+  Data = 'Data',
+  Alternative = 'Alternative',
+  Supplement = 'Supplement',
+  EncryptedPayload = 'EncryptedPayload',
+  FormData = 'EncryptedPayload',
+  Schema = 'Schema',
+  Unspecified = 'Unspecified',
+}
+
+export interface EmbeddedFileOptions {
+  mimeType?: string;
+  description?: string;
+  creationDate?: Date;
+  modificationDate?: Date;
+  afRelationship?: AFRelationship;
+}
+
+class FileEmbedder {
+  static for(bytes: Uint8Array, fileName: string, options: EmbeddedFileOptions = {}) {
+    return new FileEmbedder(bytes, fileName, options);
+  }
+
+  private readonly fileData: Uint8Array;
+  readonly fileName: string;
+  readonly options: EmbeddedFileOptions;
+
+  private constructor(fileData: Uint8Array, fileName: string, options: EmbeddedFileOptions = {}) {
+    this.fileData = fileData;
+    this.fileName = fileName;
+    this.options = options;
+  }
+
+  async embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {
+    const { mimeType, description, creationDate, modificationDate, afRelationship } = this.options;
+
+    const embeddedFileStream = context.flateStream(this.fileData, {
+      Type: 'EmbeddedFile',
+      Subtype: mimeType ?? undefined,
+      Params: {
+        Size: this.fileData.length,
+        CreationDate: creationDate ? PDFString.fromDate(creationDate) : undefined,
+        ModDate: modificationDate ? PDFString.fromDate(modificationDate) : undefined,
+      },
+    });
+    const embeddedFileStreamRef = context.register(embeddedFileStream);
+
+    const fileSpecDict = context.obj({
+      Type: 'Filespec',
+      F: PDFString.of(this.fileName), // TODO: Assert that this is plain ASCII
+      UF: PDFHexString.fromText(this.fileName),
+      EF: { F: embeddedFileStreamRef },
+      Desc: description ? PDFHexString.fromText(description) : undefined,
+      AFRelationship: afRelationship ?? undefined,
+    });
+
+    if (ref) {
+      context.assign(ref, fileSpecDict);
+      return ref;
+    } else {
+      return context.register(fileSpecDict);
+    }
+  }
+}
+
+export default FileEmbedder;

package/src/core/embedders/FontFlags.ts

@@ -0,0 +1,45 @@
+import { Font } from '../../types/fontkit';
+
+export interface FontFlagOptions {
+  fixedPitch?: boolean;
+  serif?: boolean;
+  symbolic?: boolean;
+  script?: boolean;
+  nonsymbolic?: boolean;
+  italic?: boolean;
+  allCap?: boolean;
+  smallCap?: boolean;
+  forceBold?: boolean;
+}
+
+// prettier-ignore
+const makeFontFlags = (options: FontFlagOptions) => {
+  let flags = 0;
+
+  const flipBit = (bit: number) => { flags |= (1 << (bit - 1)); };
+
+  if (options.fixedPitch)  flipBit(1);
+  if (options.serif)       flipBit(2);
+  if (options.symbolic)    flipBit(3);
+  if (options.script)      flipBit(4);
+  if (options.nonsymbolic) flipBit(6);
+  if (options.italic)      flipBit(7);
+  if (options.allCap)      flipBit(17);
+  if (options.smallCap)    flipBit(18);
+  if (options.forceBold)   flipBit(19);
+
+  return flags;
+};
+
+// From: https://github.com/foliojs/pdfkit/blob/83f5f7243172a017adcf6a7faa5547c55982c57b/lib/font/embedded.js#L123-L129
+export const deriveFontFlags = (font: Font): number => {
+  const familyClass = font['OS/2'] ? font['OS/2'].sFamilyClass : 0;
+  const flags = makeFontFlags({
+    fixedPitch: font.post.isFixedPitch,
+    serif: 1 <= familyClass && familyClass <= 7,
+    symbolic: true, // Assume the font uses non-latin characters
+    script: familyClass === 10,
+    italic: font.head.macStyle.italic,
+  });
+  return flags;
+};

package/src/core/embedders/JavaScriptEmbedder.ts

@@ -0,0 +1,34 @@
+import PDFHexString from '../objects/PDFHexString';
+import PDFContext from '../PDFContext';
+import PDFRef from '../objects/PDFRef';
+
+class JavaScriptEmbedder {
+  static for(script: string, scriptName: string) {
+    return new JavaScriptEmbedder(script, scriptName);
+  }
+
+  private readonly script: string;
+  readonly scriptName: string;
+
+  private constructor(script: string, scriptName: string) {
+    this.script = script;
+    this.scriptName = scriptName;
+  }
+
+  async embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {
+    const jsActionDict = context.obj({
+      Type: 'Action',
+      S: 'JavaScript',
+      JS: PDFHexString.fromText(this.script),
+    });
+
+    if (ref) {
+      context.assign(ref, jsActionDict);
+      return ref;
+    } else {
+      return context.register(jsActionDict);
+    }
+  }
+}
+
+export default JavaScriptEmbedder;

package/src/core/embedders/JpegEmbedder.ts

@@ -0,0 +1,118 @@
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+
+// prettier-ignore
+const MARKERS = [
+  0xffc0, 0xffc1, 0xffc2,
+  0xffc3, 0xffc5, 0xffc6,
+  0xffc7, 0xffc8, 0xffc9,
+  0xffca, 0xffcb, 0xffcc,
+  0xffcd, 0xffce, 0xffcf,
+];
+
+enum ColorSpace {
+  DeviceGray = 'DeviceGray',
+  DeviceRGB = 'DeviceRGB',
+  DeviceCMYK = 'DeviceCMYK',
+}
+
+const ChannelToColorSpace: { [idx: number]: ColorSpace | undefined } = {
+  1: ColorSpace.DeviceGray,
+  3: ColorSpace.DeviceRGB,
+  4: ColorSpace.DeviceCMYK,
+};
+
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/foliojs/pdfkit/blob/a6af76467ce06bd6a2af4aa7271ccac9ff152a7d/lib/image/jpeg.js
+ */
+class JpegEmbedder {
+  static async for(imageData: Uint8Array) {
+    const dataView = new DataView(imageData.buffer);
+
+    const soi = dataView.getUint16(0);
+    if (soi !== 0xffd8) throw new Error('SOI not found in JPEG');
+
+    let pos = 2;
+    let marker: number;
+
+    while (pos < dataView.byteLength) {
+      marker = dataView.getUint16(pos);
+      pos += 2;
+      if (MARKERS.includes(marker)) break;
+      pos += dataView.getUint16(pos);
+    }
+
+    if (!MARKERS.includes(marker!)) throw new Error('Invalid JPEG');
+    pos += 2;
+
+    const bitsPerComponent = dataView.getUint8(pos++);
+    const height = dataView.getUint16(pos);
+    pos += 2;
+
+    const width = dataView.getUint16(pos);
+    pos += 2;
+
+    const channelByte = dataView.getUint8(pos++);
+    const channelName = ChannelToColorSpace[channelByte];
+
+    if (!channelName) throw new Error('Unknown JPEG channel.');
+
+    const colorSpace = channelName;
+
+    return new JpegEmbedder(imageData, bitsPerComponent, width, height, colorSpace);
+  }
+
+  readonly bitsPerComponent: number;
+  readonly height: number;
+  readonly width: number;
+  readonly colorSpace: ColorSpace;
+
+  private readonly imageData: Uint8Array;
+
+  private constructor(
+    imageData: Uint8Array,
+    bitsPerComponent: number,
+    width: number,
+    height: number,
+    colorSpace: ColorSpace,
+  ) {
+    this.imageData = imageData;
+    this.bitsPerComponent = bitsPerComponent;
+    this.width = width;
+    this.height = height;
+    this.colorSpace = colorSpace;
+  }
+
+  async embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {
+    const xObject = context.stream(this.imageData, {
+      Type: 'XObject',
+      Subtype: 'Image',
+      BitsPerComponent: this.bitsPerComponent,
+      Width: this.width,
+      Height: this.height,
+      ColorSpace: this.colorSpace,
+      Filter: 'DCTDecode',
+
+      // CMYK JPEG streams in PDF are typically stored complemented,
+      // with 1 as 'off' and 0 as 'on' (PDF 32000-1:2008, 8.6.4.4).
+      //
+      // Standalone CMYK JPEG (usually exported by Photoshop) are
+      // stored inverse, with 0 as 'off' and 1 as 'on', like RGB.
+      //
+      // Applying a swap here as a hedge that most bytes passing
+      // through this method will benefit from it.
+      Decode: this.colorSpace === ColorSpace.DeviceCMYK ? [1, 0, 1, 0, 1, 0, 1, 0] : undefined,
+    });
+
+    if (ref) {
+      context.assign(ref, xObject);
+      return ref;
+    } else {
+      return context.register(xObject);
+    }
+  }
+}
+
+export default JpegEmbedder;

package/src/core/embedders/PDFPageEmbedder.ts

@@ -0,0 +1,139 @@
+import { MissingPageContentsEmbeddingError, UnrecognizedStreamTypeError } from '../errors';
+import PDFArray from '../objects/PDFArray';
+import PDFNumber from '../objects/PDFNumber';
+import PDFRawStream from '../objects/PDFRawStream';
+import PDFRef from '../objects/PDFRef';
+import PDFStream from '../objects/PDFStream';
+import PDFContext from '../PDFContext';
+import { decodePDFRawStream } from '../streams/decode';
+import PDFContentStream from '../structures/PDFContentStream';
+import PDFPageLeaf from '../structures/PDFPageLeaf';
+import CharCodes from '../syntax/CharCodes';
+import { TransformationMatrix } from '../../types/matrix';
+import { mergeIntoTypedArray } from '../../utils';
+
+/**
+ * Represents a page bounding box.
+ * Usually `left` and `bottom` are 0 and right, top are equal
+ * to width, height if you want to clip to the whole page.
+ *
+ *       y
+ *       ^
+ *       | +--------+ (width,height)
+ *       | |        |
+ *       | |  Page  |
+ *       | |        |
+ *       | |        |
+ * (0,0) | +--------+
+ *       +----------> x
+ */
+export interface PageBoundingBox {
+  left: number /** The left of the bounding box */;
+  bottom: number /** The bottom of the bounding box */;
+  right: number /** The right of the bounding box */;
+  top: number /** The top of the bounding box */;
+}
+
+const fullPageBoundingBox = (page: PDFPageLeaf) => {
+  const mediaBox = page.MediaBox();
+
+  const width = mediaBox.lookup(2, PDFNumber).asNumber() - mediaBox.lookup(0, PDFNumber).asNumber();
+
+  const height =
+    mediaBox.lookup(3, PDFNumber).asNumber() - mediaBox.lookup(1, PDFNumber).asNumber();
+
+  return { left: 0, bottom: 0, right: width, top: height };
+};
+
+// Returns the identity matrix, modified to position the content of the given
+// bounding box at (0, 0).
+const boundingBoxAdjustedMatrix = (bb: PageBoundingBox): TransformationMatrix => [
+  1,
+  0,
+  0,
+  1,
+  -bb.left,
+  -bb.bottom,
+];
+
+class PDFPageEmbedder {
+  static async for(
+    page: PDFPageLeaf,
+    boundingBox?: PageBoundingBox,
+    transformationMatrix?: TransformationMatrix,
+  ) {
+    return new PDFPageEmbedder(page, boundingBox, transformationMatrix);
+  }
+
+  readonly width: number;
+  readonly height: number;
+  readonly boundingBox: PageBoundingBox;
+  readonly transformationMatrix: TransformationMatrix;
+
+  private readonly page: PDFPageLeaf;
+
+  private constructor(
+    page: PDFPageLeaf,
+    boundingBox?: PageBoundingBox,
+    transformationMatrix?: TransformationMatrix,
+  ) {
+    this.page = page;
+
+    const bb = boundingBox ?? fullPageBoundingBox(page);
+
+    this.width = bb.right - bb.left;
+    this.height = bb.top - bb.bottom;
+    this.boundingBox = bb;
+    this.transformationMatrix = transformationMatrix ?? boundingBoxAdjustedMatrix(bb);
+  }
+
+  async embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {
+    const { Contents, Resources } = this.page.normalizedEntries();
+
+    if (!Contents) throw new MissingPageContentsEmbeddingError();
+    const decodedContents = this.decodeContents(Contents);
+
+    const { left, bottom, right, top } = this.boundingBox;
+    const xObject = context.flateStream(decodedContents, {
+      Type: 'XObject',
+      Subtype: 'Form',
+      FormType: 1,
+      BBox: [left, bottom, right, top],
+      Matrix: this.transformationMatrix,
+      Resources,
+    });
+
+    if (ref) {
+      context.assign(ref, xObject);
+      return ref;
+    } else {
+      return context.register(xObject);
+    }
+  }
+
+  // `contents` is an array of streams which are merged to include them in the XObject.
+  // This methods extracts each stream and joins them with a newline character.
+  private decodeContents(contents: PDFArray) {
+    const newline = Uint8Array.of(CharCodes.Newline);
+    const decodedContents: Uint8Array[] = [];
+
+    for (let idx = 0, len = contents.size(); idx < len; idx++) {
+      const stream = contents.lookup(idx, PDFStream);
+
+      let content: Uint8Array;
+      if (stream instanceof PDFRawStream) {
+        content = decodePDFRawStream(stream).decode();
+      } else if (stream instanceof PDFContentStream) {
+        content = stream.getUnencodedContents();
+      } else {
+        throw new UnrecognizedStreamTypeError(stream);
+      }
+
+      decodedContents.push(content, newline);
+    }
+
+    return mergeIntoTypedArray(...decodedContents);
+  }
+}
+
+export default PDFPageEmbedder;

package/src/core/embedders/PngEmbedder.ts

@@ -0,0 +1,69 @@
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import { PNG } from '../../utils/png';
+
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/devongovett/pdfkit/blob/e71edab0dd4657b5a767804ba86c94c58d01fbca/lib/image/png.coffee
+ */
+class PngEmbedder {
+  static async for(imageData: Uint8Array) {
+    const png = PNG.load(imageData);
+    return new PngEmbedder(png);
+  }
+
+  readonly bitsPerComponent: number;
+  readonly height: number;
+  readonly width: number;
+  readonly colorSpace: 'DeviceRGB';
+
+  private readonly image: PNG;
+
+  private constructor(png: PNG) {
+    this.image = png;
+    this.bitsPerComponent = png.bitsPerComponent;
+    this.width = png.width;
+    this.height = png.height;
+    this.colorSpace = 'DeviceRGB';
+  }
+
+  async embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {
+    const SMask = this.embedAlphaChannel(context);
+
+    const xObject = context.flateStream(this.image.rgbChannel, {
+      Type: 'XObject',
+      Subtype: 'Image',
+      BitsPerComponent: this.image.bitsPerComponent,
+      Width: this.image.width,
+      Height: this.image.height,
+      ColorSpace: this.colorSpace,
+      SMask,
+    });
+
+    if (ref) {
+      context.assign(ref, xObject);
+      return ref;
+    } else {
+      return context.register(xObject);
+    }
+  }
+
+  private embedAlphaChannel(context: PDFContext): PDFRef | undefined {
+    if (!this.image.alphaChannel) return undefined;
+
+    const xObject = context.flateStream(this.image.alphaChannel, {
+      Type: 'XObject',
+      Subtype: 'Image',
+      Height: this.image.height,
+      Width: this.image.width,
+      BitsPerComponent: this.image.bitsPerComponent,
+      ColorSpace: 'DeviceGray',
+      Decode: [0, 1],
+    });
+
+    return context.register(xObject);
+  }
+}
+
+export default PngEmbedder;

package/src/core/embedders/StandardFontEmbedder.ts

@@ -0,0 +1,121 @@
+import { Encodings, Font, FontNames, EncodingType } from '@pdf-lib/standard-fonts';
+
+import PDFHexString from '../objects/PDFHexString';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import { toCodePoint, toHexString } from '../../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;