@adnsistemas/pdf-lib 1.18.0

package/src/core/embedders/CustomFontSubsetEmbedder.ts

@@ -0,0 +1,84 @@
+import { Font, Fontkit, Glyph, Subset, TypeFeatures } from 'src/types/fontkit';
+
+import CustomFontEmbedder from 'src/core/embedders/CustomFontEmbedder';
+import PDFHexString from 'src/core/objects/PDFHexString';
+import { Cache, mergeUint8Arrays, toHexStringOfMinLength } from 'src/utils';
+
+/**
+ * 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/jpeg.coffee
+ */
+class CustomFontSubsetEmbedder extends CustomFontEmbedder {
+  static async for(
+    fontkit: Fontkit,
+    fontData: Uint8Array,
+    customFontName?: string,
+    fontFeatures?: TypeFeatures,
+  ) {
+    const font = await fontkit.create(fontData);
+    return new CustomFontSubsetEmbedder(
+      font,
+      fontData,
+      customFontName,
+      fontFeatures,
+    );
+  }
+
+  private readonly subset: Subset;
+  private readonly glyphs: Glyph[];
+  private readonly glyphIdMap: Map<number, number>;
+
+  private constructor(
+    font: Font,
+    fontData: Uint8Array,
+    customFontName?: string,
+    fontFeatures?: TypeFeatures,
+  ) {
+    super(font, fontData, customFontName, fontFeatures);
+
+    this.subset = this.font.createSubset();
+    this.glyphs = [];
+    this.glyphCache = Cache.populatedBy(() => this.glyphs);
+    this.glyphIdMap = new Map();
+  }
+
+  encodeText(text: string): PDFHexString {
+    const { glyphs } = this.font.layout(text, this.fontFeatures);
+    const hexCodes = new Array(glyphs.length);
+
+    for (let idx = 0, len = glyphs.length; idx < len; idx++) {
+      const glyph = glyphs[idx];
+      const subsetGlyphId = this.subset.includeGlyph(glyph);
+
+      this.glyphs[subsetGlyphId - 1] = glyph;
+      this.glyphIdMap.set(glyph.id, subsetGlyphId);
+
+      hexCodes[idx] = toHexStringOfMinLength(subsetGlyphId, 4);
+    }
+
+    this.glyphCache.invalidate();
+    return PDFHexString.of(hexCodes.join(''));
+  }
+
+  protected isCFF(): boolean {
+    return (this.subset as any).cff;
+  }
+
+  protected glyphId(glyph?: Glyph): number {
+    return glyph ? this.glyphIdMap.get(glyph.id)! : -1;
+  }
+
+  protected serializeFont(): Promise<Uint8Array> {
+    return new Promise((resolve, reject) => {
+      const parts: Uint8Array[] = [];
+      this.subset
+        .encodeStream()
+        .on('data', (bytes) => parts.push(bytes))
+        .on('end', () => resolve(mergeUint8Arrays(parts)))
+        .on('error' as any, (err) => reject(err));
+    });
+  }
+}
+
+export default CustomFontSubsetEmbedder;

package/src/core/embedders/FileEmbedder.ts

@@ -0,0 +1,95 @@
+import PDFString from 'src/core/objects/PDFString';
+import PDFHexString from 'src/core/objects/PDFHexString';
+import PDFContext from 'src/core/PDFContext';
+import PDFRef from 'src/core/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 'src/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 'src/core/objects/PDFHexString';
+import PDFContext from 'src/core/PDFContext';
+import PDFRef from 'src/core/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,127 @@
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFContext from 'src/core/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,141 @@
+import {
+  MissingPageContentsEmbeddingError,
+  UnrecognizedStreamTypeError,
+} from 'src/core/errors';
+import PDFArray from 'src/core/objects/PDFArray';
+import PDFNumber from 'src/core/objects/PDFNumber';
+import PDFRawStream from 'src/core/objects/PDFRawStream';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFStream from 'src/core/objects/PDFStream';
+import PDFContext from 'src/core/PDFContext';
+import { decodePDFRawStream } from 'src/core/streams/decode';
+import PDFContentStream from 'src/core/structures/PDFContentStream';
+import PDFPageLeaf from 'src/core/structures/PDFPageLeaf';
+import CharCodes from 'src/core/syntax/CharCodes';
+import { TransformationMatrix } from 'src/types/matrix';
+import { mergeIntoTypedArray } from 'src/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 'src/core/objects/PDFRef';
+import PDFContext from 'src/core/PDFContext';
+import { PNG } from 'src/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;