@pdfme/pdf-lib 0.0.0

package/src/core/document/PDFCrossRefSection.ts

@@ -0,0 +1,161 @@
+import PDFRef from '../objects/PDFRef';
+import CharCodes from '../syntax/CharCodes';
+import { copyStringIntoBuffer, padStart } from '../../utils';
+
+export interface Entry {
+  ref: PDFRef;
+  offset: number;
+  deleted: boolean;
+}
+
+/**
+ * Entries should be added using the [[addEntry]] and [[addDeletedEntry]]
+ * methods **in order of ascending object number**.
+ */
+class PDFCrossRefSection {
+  static create = () =>
+    new PDFCrossRefSection({
+      ref: PDFRef.of(0, 65535),
+      offset: 0,
+      deleted: true,
+    });
+
+  static createEmpty = () => new PDFCrossRefSection();
+
+  private subsections: Entry[][];
+  private chunkIdx: number;
+  private chunkLength: number;
+
+  private constructor(firstEntry: Entry | void) {
+    this.subsections = firstEntry ? [[firstEntry]] : [];
+    this.chunkIdx = 0;
+    this.chunkLength = firstEntry ? 1 : 0;
+  }
+
+  addEntry(ref: PDFRef, offset: number): void {
+    this.append({ ref, offset, deleted: false });
+  }
+
+  addDeletedEntry(ref: PDFRef, nextFreeObjectNumber: number): void {
+    this.append({ ref, offset: nextFreeObjectNumber, deleted: true });
+  }
+
+  toString(): string {
+    let section = `xref\n`;
+
+    for (let rangeIdx = 0, rangeLen = this.subsections.length; rangeIdx < rangeLen; rangeIdx++) {
+      const range = this.subsections[rangeIdx];
+      section += `${range[0].ref.objectNumber} ${range.length}\n`;
+      for (let entryIdx = 0, entryLen = range.length; entryIdx < entryLen; entryIdx++) {
+        const entry = range[entryIdx];
+        section += padStart(String(entry.offset), 10, '0');
+        section += ' ';
+        section += padStart(String(entry.ref.generationNumber), 5, '0');
+        section += ' ';
+        section += entry.deleted ? 'f' : 'n';
+        section += ' \n';
+      }
+    }
+
+    return section;
+  }
+
+  sizeInBytes(): number {
+    let size = 5;
+    for (let idx = 0, len = this.subsections.length; idx < len; idx++) {
+      const subsection = this.subsections[idx];
+      const subsectionLength = subsection.length;
+      const [firstEntry] = subsection;
+      size += 2;
+      size += String(firstEntry.ref.objectNumber).length;
+      size += String(subsectionLength).length;
+      size += 20 * subsectionLength;
+    }
+    return size;
+  }
+
+  copyBytesInto(buffer: Uint8Array, offset: number): number {
+    const initialOffset = offset;
+
+    buffer[offset++] = CharCodes.x;
+    buffer[offset++] = CharCodes.r;
+    buffer[offset++] = CharCodes.e;
+    buffer[offset++] = CharCodes.f;
+    buffer[offset++] = CharCodes.Newline;
+
+    offset += this.copySubsectionsIntoBuffer(this.subsections, buffer, offset);
+
+    return offset - initialOffset;
+  }
+
+  private copySubsectionsIntoBuffer(
+    subsections: Entry[][],
+    buffer: Uint8Array,
+    offset: number,
+  ): number {
+    const initialOffset = offset;
+    const length = subsections.length;
+
+    for (let idx = 0; idx < length; idx++) {
+      const subsection = this.subsections[idx];
+
+      const firstObjectNumber = String(subsection[0].ref.objectNumber);
+      offset += copyStringIntoBuffer(firstObjectNumber, buffer, offset);
+      buffer[offset++] = CharCodes.Space;
+
+      const rangeLength = String(subsection.length);
+      offset += copyStringIntoBuffer(rangeLength, buffer, offset);
+      buffer[offset++] = CharCodes.Newline;
+
+      offset += this.copyEntriesIntoBuffer(subsection, buffer, offset);
+    }
+
+    return offset - initialOffset;
+  }
+
+  private copyEntriesIntoBuffer(entries: Entry[], buffer: Uint8Array, offset: number): number {
+    const length = entries.length;
+
+    for (let idx = 0; idx < length; idx++) {
+      const entry = entries[idx];
+
+      const entryOffset = padStart(String(entry.offset), 10, '0');
+      offset += copyStringIntoBuffer(entryOffset, buffer, offset);
+      buffer[offset++] = CharCodes.Space;
+
+      const entryGen = padStart(String(entry.ref.generationNumber), 5, '0');
+      offset += copyStringIntoBuffer(entryGen, buffer, offset);
+      buffer[offset++] = CharCodes.Space;
+
+      buffer[offset++] = entry.deleted ? CharCodes.f : CharCodes.n;
+
+      buffer[offset++] = CharCodes.Space;
+      buffer[offset++] = CharCodes.Newline;
+    }
+
+    return 20 * length;
+  }
+
+  private append(currEntry: Entry): void {
+    if (this.chunkLength === 0) {
+      this.subsections.push([currEntry]);
+      this.chunkIdx = 0;
+      this.chunkLength = 1;
+      return;
+    }
+
+    const chunk = this.subsections[this.chunkIdx];
+    const prevEntry = chunk[this.chunkLength - 1];
+
+    if (currEntry.ref.objectNumber - prevEntry.ref.objectNumber > 1) {
+      this.subsections.push([currEntry]);
+      this.chunkIdx += 1;
+      this.chunkLength = 1;
+    } else {
+      chunk.push(currEntry);
+      this.chunkLength += 1;
+    }
+  }
+}
+
+export default PDFCrossRefSection;

package/src/core/document/PDFHeader.ts

@@ -0,0 +1,48 @@
+import CharCodes from '../syntax/CharCodes';
+import { charFromCode, copyStringIntoBuffer } from '../../utils';
+
+class PDFHeader {
+  static forVersion = (major: number, minor: number) => new PDFHeader(major, minor);
+
+  private readonly major: string;
+  private readonly minor: string;
+
+  private constructor(major: number, minor: number) {
+    this.major = String(major);
+    this.minor = String(minor);
+  }
+
+  toString(): string {
+    const bc = charFromCode(129);
+    return `%PDF-${this.major}.${this.minor}\n%${bc}${bc}${bc}${bc}`;
+  }
+
+  sizeInBytes(): number {
+    return 12 + this.major.length + this.minor.length;
+  }
+
+  copyBytesInto(buffer: Uint8Array, offset: number): number {
+    const initialOffset = offset;
+
+    buffer[offset++] = CharCodes.Percent;
+    buffer[offset++] = CharCodes.P;
+    buffer[offset++] = CharCodes.D;
+    buffer[offset++] = CharCodes.F;
+    buffer[offset++] = CharCodes.Dash;
+
+    offset += copyStringIntoBuffer(this.major, buffer, offset);
+    buffer[offset++] = CharCodes.Period;
+    offset += copyStringIntoBuffer(this.minor, buffer, offset);
+    buffer[offset++] = CharCodes.Newline;
+
+    buffer[offset++] = CharCodes.Percent;
+    buffer[offset++] = 129;
+    buffer[offset++] = 129;
+    buffer[offset++] = 129;
+    buffer[offset++] = 129;
+
+    return offset - initialOffset;
+  }
+}
+
+export default PDFHeader;

package/src/core/document/PDFTrailer.ts

@@ -0,0 +1,48 @@
+import CharCodes from '../syntax/CharCodes';
+import { copyStringIntoBuffer } from '../../utils';
+
+class PDFTrailer {
+  static forLastCrossRefSectionOffset = (offset: number) => new PDFTrailer(offset);
+
+  private readonly lastXRefOffset: string;
+
+  private constructor(lastXRefOffset: number) {
+    this.lastXRefOffset = String(lastXRefOffset);
+  }
+
+  toString(): string {
+    return `startxref\n${this.lastXRefOffset}\n%%EOF`;
+  }
+
+  sizeInBytes(): number {
+    return 16 + this.lastXRefOffset.length;
+  }
+
+  copyBytesInto(buffer: Uint8Array, offset: number): number {
+    const initialOffset = offset;
+
+    buffer[offset++] = CharCodes.s;
+    buffer[offset++] = CharCodes.t;
+    buffer[offset++] = CharCodes.a;
+    buffer[offset++] = CharCodes.r;
+    buffer[offset++] = CharCodes.t;
+    buffer[offset++] = CharCodes.x;
+    buffer[offset++] = CharCodes.r;
+    buffer[offset++] = CharCodes.e;
+    buffer[offset++] = CharCodes.f;
+    buffer[offset++] = CharCodes.Newline;
+
+    offset += copyStringIntoBuffer(this.lastXRefOffset, buffer, offset);
+
+    buffer[offset++] = CharCodes.Newline;
+    buffer[offset++] = CharCodes.Percent;
+    buffer[offset++] = CharCodes.Percent;
+    buffer[offset++] = CharCodes.E;
+    buffer[offset++] = CharCodes.O;
+    buffer[offset++] = CharCodes.F;
+
+    return offset - initialOffset;
+  }
+}
+
+export default PDFTrailer;

package/src/core/document/PDFTrailerDict.ts

@@ -0,0 +1,39 @@
+import PDFDict from '../objects/PDFDict';
+import CharCodes from '../syntax/CharCodes';
+
+class PDFTrailerDict {
+  static of = (dict: PDFDict) => new PDFTrailerDict(dict);
+
+  readonly dict: PDFDict;
+
+  private constructor(dict: PDFDict) {
+    this.dict = dict;
+  }
+
+  toString(): string {
+    return `trailer\n${this.dict.toString()}`;
+  }
+
+  sizeInBytes(): number {
+    return 8 + this.dict.sizeInBytes();
+  }
+
+  copyBytesInto(buffer: Uint8Array, offset: number): number {
+    const initialOffset = offset;
+
+    buffer[offset++] = CharCodes.t;
+    buffer[offset++] = CharCodes.r;
+    buffer[offset++] = CharCodes.a;
+    buffer[offset++] = CharCodes.i;
+    buffer[offset++] = CharCodes.l;
+    buffer[offset++] = CharCodes.e;
+    buffer[offset++] = CharCodes.r;
+    buffer[offset++] = CharCodes.Newline;
+
+    offset += this.dict.copyBytesInto(buffer, offset);
+
+    return offset - initialOffset;
+  }
+}
+
+export default PDFTrailerDict;

package/src/core/embedders/CMap.ts

@@ -0,0 +1,65 @@
+import { Glyph } from '../../types/fontkit';
+
+import { toHexString, toHexStringOfMinLength } from '../../utils';
+import { hasSurrogates, highSurrogate, isWithinBMP, lowSurrogate } from '../../utils/unicode';
+
+/** [fontId, codePoint] */
+type BfChar = [string, string];
+
+/** `glyphs` should be an array of unique glyphs */
+export const createCmap = (glyphs: Glyph[], glyphId: (g?: Glyph) => number) => {
+  const bfChars: BfChar[] = new Array(glyphs.length);
+  for (let idx = 0, len = glyphs.length; idx < len; idx++) {
+    const glyph = glyphs[idx];
+    const id = cmapHexFormat(cmapHexString(glyphId(glyph)));
+    const unicode = cmapHexFormat(...glyph.codePoints.map(cmapCodePointFormat));
+    bfChars[idx] = [id, unicode];
+  }
+
+  return fillCmapTemplate(bfChars);
+};
+
+/* =============================== Templates ================================ */
+
+const fillCmapTemplate = (bfChars: BfChar[]) => `\
+/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CIDSystemInfo <<
+  /Registry (Adobe)
+  /Ordering (UCS)
+  /Supplement 0
+>> def
+/CMapName /Adobe-Identity-UCS def
+/CMapType 2 def
+1 begincodespacerange
+<0000><ffff>
+endcodespacerange
+${bfChars.length} beginbfchar
+${bfChars.map(([glyphId, codePoint]) => `${glyphId} ${codePoint}`).join('\n')}
+endbfchar
+endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end\
+`;
+
+/* =============================== Utilities ================================ */
+
+const cmapHexFormat = (...values: string[]) => `<${values.join('')}>`;
+
+const cmapHexString = (value: number) => toHexStringOfMinLength(value, 4);
+
+const cmapCodePointFormat = (codePoint: number) => {
+  if (isWithinBMP(codePoint)) return cmapHexString(codePoint);
+
+  if (hasSurrogates(codePoint)) {
+    const hs = highSurrogate(codePoint);
+    const ls = lowSurrogate(codePoint);
+    return `${cmapHexString(hs)}${cmapHexString(ls)}`;
+  }
+
+  const hex = toHexString(codePoint);
+  const msg = `0x${hex} is not a valid UTF-8 or UTF-16 codepoint.`;
+  throw new Error(msg);
+};

package/src/core/embedders/CustomFontEmbedder.ts

@@ -0,0 +1,237 @@
+import { Font, Fontkit, Glyph, TypeFeatures } from '../../types/fontkit';
+
+import { createCmap } from './CMap';
+import { deriveFontFlags } from './FontFlags';
+import PDFHexString from '../objects/PDFHexString';
+import PDFRef from '../objects/PDFRef';
+import PDFString from '../objects/PDFString';
+import PDFContext from '../PDFContext';
+import { byAscendingId, Cache, sortedUniq, toHexStringOfMinLength } from '../../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 CustomFontEmbedder {
+  static async for(
+    fontkit: Fontkit,
+    fontData: Uint8Array,
+    customName?: string,
+    fontFeatures?: TypeFeatures,
+  ) {
+    const font = await fontkit.create(fontData);
+    return new CustomFontEmbedder(font, fontData, customName, fontFeatures);
+  }
+
+  readonly font: Font;
+  readonly scale: number;
+  readonly fontData: Uint8Array;
+  readonly fontName: string;
+  readonly customName: string | undefined;
+  readonly fontFeatures: TypeFeatures | undefined;
+
+  protected baseFontName: string;
+  protected glyphCache: Cache<Glyph[]>;
+
+  protected constructor(
+    font: Font,
+    fontData: Uint8Array,
+    customName?: string,
+    fontFeatures?: TypeFeatures,
+  ) {
+    this.font = font;
+    this.scale = 1000 / this.font.unitsPerEm;
+    this.fontData = fontData;
+    this.fontName = this.font.postscriptName || 'Font';
+    this.customName = customName;
+    this.fontFeatures = fontFeatures;
+
+    this.baseFontName = '';
+    this.glyphCache = Cache.populatedBy(this.allGlyphsInFontSortedById);
+  }
+
+  /**
+   * Encode the JavaScript string into this font. (JavaScript encodes strings in
+   * Unicode, but embedded fonts use their own custom encodings)
+   */
+  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++) {
+      hexCodes[idx] = toHexStringOfMinLength(glyphs[idx].id, 4);
+    }
+    return PDFHexString.of(hexCodes.join(''));
+  }
+
+  // The advanceWidth takes into account kerning automatically, so we don't
+  // have to do that manually like we do for the standard fonts.
+  widthOfTextAtSize(text: string, size: number): number {
+    const { glyphs } = this.font.layout(text, this.fontFeatures);
+    let totalWidth = 0;
+    for (let idx = 0, len = glyphs.length; idx < len; idx++) {
+      totalWidth += glyphs[idx].advanceWidth * this.scale;
+    }
+    const scale = size / 1000;
+    return totalWidth * scale;
+  }
+
+  heightOfFontAtSize(size: number, options: { descender?: boolean } = {}): number {
+    const { descender = true } = options;
+
+    const { ascent, descent, bbox } = this.font;
+    const yTop = (ascent || bbox.maxY) * this.scale;
+    const yBottom = (descent || bbox.minY) * this.scale;
+
+    let height = yTop - yBottom;
+    if (!descender) height -= Math.abs(descent) || 0;
+
+    return (height / 1000) * size;
+  }
+
+  sizeOfFontAtHeight(height: number): number {
+    const { ascent, descent, bbox } = this.font;
+    const yTop = (ascent || bbox.maxY) * this.scale;
+    const yBottom = (descent || bbox.minY) * this.scale;
+    return (1000 * height) / (yTop - yBottom);
+  }
+
+  embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {
+    this.baseFontName = this.customName || context.addRandomSuffix(this.fontName);
+    return this.embedFontDict(context, ref);
+  }
+
+  protected async embedFontDict(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {
+    const cidFontDictRef = await this.embedCIDFontDict(context);
+    const unicodeCMapRef = this.embedUnicodeCmap(context);
+
+    const fontDict = context.obj({
+      Type: 'Font',
+      Subtype: 'Type0',
+      BaseFont: this.baseFontName,
+      Encoding: 'Identity-H',
+      DescendantFonts: [cidFontDictRef],
+      ToUnicode: unicodeCMapRef,
+    });
+
+    if (ref) {
+      context.assign(ref, fontDict);
+      return ref;
+    } else {
+      return context.register(fontDict);
+    }
+  }
+
+  protected isCFF(): boolean {
+    return this.font.cff;
+  }
+
+  protected async embedCIDFontDict(context: PDFContext): Promise<PDFRef> {
+    const fontDescriptorRef = await this.embedFontDescriptor(context);
+
+    const cidFontDict = context.obj({
+      Type: 'Font',
+      Subtype: this.isCFF() ? 'CIDFontType0' : 'CIDFontType2',
+      CIDToGIDMap: 'Identity',
+      BaseFont: this.baseFontName,
+      CIDSystemInfo: {
+        Registry: PDFString.of('Adobe'),
+        Ordering: PDFString.of('Identity'),
+        Supplement: 0,
+      },
+      FontDescriptor: fontDescriptorRef,
+      W: this.computeWidths(),
+    });
+
+    return context.register(cidFontDict);
+  }
+
+  protected async embedFontDescriptor(context: PDFContext): Promise<PDFRef> {
+    const fontStreamRef = await this.embedFontStream(context);
+
+    const { scale } = this;
+    const { italicAngle, ascent, descent, capHeight, xHeight } = this.font;
+    const { minX, minY, maxX, maxY } = this.font.bbox;
+
+    const fontDescriptor = context.obj({
+      Type: 'FontDescriptor',
+      FontName: this.baseFontName,
+      Flags: deriveFontFlags(this.font),
+      FontBBox: [minX * scale, minY * scale, maxX * scale, maxY * scale],
+      ItalicAngle: italicAngle,
+      Ascent: ascent * scale,
+      Descent: descent * scale,
+      CapHeight: (capHeight || ascent) * scale,
+      XHeight: (xHeight || 0) * scale,
+
+      // Not sure how to compute/find this, nor is anybody else really:
+      // https://stackoverflow.com/questions/35485179/stemv-value-of-the-truetype-font
+      StemV: 0,
+
+      [this.isCFF() ? 'FontFile3' : 'FontFile2']: fontStreamRef,
+    });
+
+    return context.register(fontDescriptor);
+  }
+
+  protected async serializeFont(): Promise<Uint8Array> {
+    return this.fontData;
+  }
+
+  protected async embedFontStream(context: PDFContext): Promise<PDFRef> {
+    const fontStream = context.flateStream(await this.serializeFont(), {
+      Subtype: this.isCFF() ? 'CIDFontType0C' : undefined,
+    });
+    return context.register(fontStream);
+  }
+
+  protected embedUnicodeCmap(context: PDFContext): PDFRef {
+    const cmap = createCmap(this.glyphCache.access(), this.glyphId.bind(this));
+    const cmapStream = context.flateStream(cmap);
+    return context.register(cmapStream);
+  }
+
+  protected glyphId(glyph?: Glyph): number {
+    return glyph ? glyph.id : -1;
+  }
+
+  protected computeWidths(): (number | number[])[] {
+    const glyphs = this.glyphCache.access();
+
+    const widths: (number | number[])[] = [];
+    let currSection: number[] = [];
+
+    for (let idx = 0, len = glyphs.length; idx < len; idx++) {
+      const currGlyph = glyphs[idx];
+      const prevGlyph = glyphs[idx - 1];
+
+      const currGlyphId = this.glyphId(currGlyph);
+      const prevGlyphId = this.glyphId(prevGlyph);
+
+      if (idx === 0) {
+        widths.push(currGlyphId);
+      } else if (currGlyphId - prevGlyphId !== 1) {
+        widths.push(currSection);
+        widths.push(currGlyphId);
+        currSection = [];
+      }
+
+      currSection.push(currGlyph.advanceWidth * this.scale);
+    }
+
+    widths.push(currSection);
+
+    return widths;
+  }
+
+  private allGlyphsInFontSortedById = (): Glyph[] => {
+    const glyphs: Glyph[] = new Array(this.font.characterSet.length);
+    for (let idx = 0, len = glyphs.length; idx < len; idx++) {
+      const codePoint = this.font.characterSet[idx];
+      glyphs[idx] = this.font.glyphForCodePoint(codePoint);
+    }
+    return sortedUniq(glyphs.sort(byAscendingId), (g) => g.id);
+  };
+}
+
+export default CustomFontEmbedder;

package/src/core/embedders/CustomFontSubsetEmbedder.ts

@@ -0,0 +1,89 @@
+import { Font, Fontkit, Glyph, Subset, TypeFeatures } from '../../types/fontkit';
+
+import CustomFontEmbedder from './CustomFontEmbedder';
+import PDFHexString from '../objects/PDFHexString';
+import { Cache, mergeUint8Arrays, toHexStringOfMinLength } from '../../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) => {
+      if ('encodeStream' in this.subset) {
+        const parts: Uint8Array[] = [];
+        this.subset
+          .encodeStream()
+          .on('data', (bytes) => parts.push(bytes))
+          .on('end', () => resolve(mergeUint8Arrays(parts)))
+          .on('error' as any, (err) => reject(err));
+      } else if ('encode' in this.subset) {
+        try {
+          resolve(this.subset.encode());
+        } catch (err) {
+          reject(err);
+        }
+      } else {
+        reject(new Error('Subset does not have an encode method'));
+      }
+    });
+  }
+}
+
+export default CustomFontSubsetEmbedder;