@pdfme/pdf-lib 6.0.3-dev.0 → 6.0.4-dev.1

package/src/core/embedders/FileEmbedder.ts

@@ -1,77 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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 = 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[] = 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;