@pdfme/pdf-lib 6.0.3 → 6.0.5-dev.1

package/src/core/document/PDFCrossRefSection.ts

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

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

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

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

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

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

@@ -1,89 +0,0 @@
-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 = 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 = 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;