pdfmake 0.3.0-beta.6 → 0.3.0-beta.8

package/js/Printer.js

@@ -1,290 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.default = void 0;
-var _PDFDocument = _interopRequireDefault(require("./PDFDocument"));
-var _LayoutBuilder = _interopRequireDefault(require("./LayoutBuilder"));
-var _SVGMeasure = _interopRequireDefault(require("./SVGMeasure"));
-var _PageSize = require("./PageSize");
-var _tableLayouts = require("./tableLayouts");
-var _Renderer = _interopRequireDefault(require("./Renderer"));
-var _variableType = require("./helpers/variableType");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
- * Printer which turns document definition into a pdf
- *
- * @example
- * var fontDescriptors = {
- *	Roboto: {
- *		normal: 'fonts/Roboto-Regular.ttf',
- *		bold: 'fonts/Roboto-Medium.ttf',
- *		italics: 'fonts/Roboto-Italic.ttf',
- *		bolditalics: 'fonts/Roboto-MediumItalic.ttf'
- *	}
- * };
- *
- * var printer = new PdfPrinter(fontDescriptors);
- */
-class PdfPrinter {
-  /**
-   * @param {object} fontDescriptors font definition dictionary
-   * @param {object} virtualfs
-   * @param {object} urlResolver
-   */
-  constructor(fontDescriptors, virtualfs = null, urlResolver = null) {
-    this.fontDescriptors = fontDescriptors;
-    this.virtualfs = virtualfs;
-    this.urlResolver = urlResolver;
-  }
-
-  /**
-   * Executes layout engine for the specified document and renders it into a pdfkit document
-   * ready to be saved.
-   *
-   * @param {object} docDefinition
-   * @param {object} options
-   * @returns {Promise<PDFDocument>} resolved promise return a pdfkit document
-   */
-  createPdfKitDocument(docDefinition, options = {}) {
-    return new Promise((resolve, reject) => {
-      this.resolveUrls(docDefinition).then(() => {
-        try {
-          docDefinition.version = docDefinition.version || '1.3';
-          docDefinition.compress = typeof docDefinition.compress === 'boolean' ? docDefinition.compress : true;
-          docDefinition.images = docDefinition.images || {};
-          docDefinition.attachments = docDefinition.attachments || {};
-          docDefinition.pageMargins = (0, _variableType.isValue)(docDefinition.pageMargins) ? docDefinition.pageMargins : 40;
-          docDefinition.patterns = docDefinition.patterns || {};
-          let pageSize = (0, _PageSize.normalizePageSize)(docDefinition.pageSize, docDefinition.pageOrientation);
-          let pdfOptions = {
-            size: [pageSize.width, pageSize.height],
-            pdfVersion: docDefinition.version,
-            compress: docDefinition.compress,
-            userPassword: docDefinition.userPassword,
-            ownerPassword: docDefinition.ownerPassword,
-            permissions: docDefinition.permissions,
-            fontLayoutCache: typeof options.fontLayoutCache === 'boolean' ? options.fontLayoutCache : true,
-            bufferPages: options.bufferPages || false,
-            autoFirstPage: false,
-            info: createMetadata(docDefinition),
-            font: null
-          };
-          this.pdfKitDoc = new _PDFDocument.default(this.fontDescriptors, docDefinition.images, docDefinition.patterns, docDefinition.attachments, pdfOptions, this.virtualfs);
-          embedFiles(docDefinition, this.pdfKitDoc);
-          const builder = new _LayoutBuilder.default(pageSize, (0, _PageSize.normalizePageMargin)(docDefinition.pageMargins), new _SVGMeasure.default());
-          builder.registerTableLayouts(_tableLayouts.tableLayouts);
-          if (options.tableLayouts) {
-            builder.registerTableLayouts(options.tableLayouts);
-          }
-          let pages = builder.layoutDocument(docDefinition.content, this.pdfKitDoc, docDefinition.styles || {}, docDefinition.defaultStyle || {
-            fontSize: 12,
-            font: 'Roboto'
-          }, docDefinition.background, docDefinition.header, docDefinition.footer, docDefinition.watermark, docDefinition.pageBreakBefore);
-          let maxNumberPages = docDefinition.maxPagesNumber || -1;
-          if ((0, _variableType.isNumber)(maxNumberPages) && maxNumberPages > -1) {
-            pages = pages.slice(0, maxNumberPages);
-          }
-
-          // if pageSize.height is set to Infinity, calculate the actual height of the page that
-          // was laid out using the height of each of the items in the page.
-          if (pageSize.height === Infinity) {
-            let pageHeight = calculatePageHeight(pages, docDefinition.pageMargins);
-            this.pdfKitDoc.options.size = [pageSize.width, pageHeight];
-          }
-          const renderer = new _Renderer.default(this.pdfKitDoc, options.progressCallback);
-          renderer.renderPages(pages);
-          resolve(this.pdfKitDoc);
-        } catch (e) {
-          reject(e);
-        }
-      }, result => {
-        reject(result);
-      });
-    });
-  }
-
-  /**
-   * @param {object} docDefinition
-   * @returns {Promise}
-   */
-  resolveUrls(docDefinition) {
-    const getExtendedUrl = url => {
-      if (typeof url === 'object') {
-        return {
-          url: url.url,
-          headers: url.headers
-        };
-      }
-      return {
-        url: url,
-        headers: {}
-      };
-    };
-    return new Promise((resolve, reject) => {
-      if (this.urlResolver === null) {
-        resolve();
-      }
-      for (let font in this.fontDescriptors) {
-        if (this.fontDescriptors.hasOwnProperty(font)) {
-          if (this.fontDescriptors[font].normal) {
-            if (Array.isArray(this.fontDescriptors[font].normal)) {
-              // TrueType Collection
-              let url = getExtendedUrl(this.fontDescriptors[font].normal[0]);
-              this.urlResolver.resolve(url.url, url.headers);
-              this.fontDescriptors[font].normal[0] = url.url;
-            } else {
-              let url = getExtendedUrl(this.fontDescriptors[font].normal);
-              this.urlResolver.resolve(url.url, url.headers);
-              this.fontDescriptors[font].normal = url.url;
-            }
-          }
-          if (this.fontDescriptors[font].bold) {
-            if (Array.isArray(this.fontDescriptors[font].bold)) {
-              // TrueType Collection
-              let url = getExtendedUrl(this.fontDescriptors[font].bold[0]);
-              this.urlResolver.resolve(url.url, url.headers);
-              this.fontDescriptors[font].bold[0] = url.url;
-            } else {
-              let url = getExtendedUrl(this.fontDescriptors[font].bold);
-              this.urlResolver.resolve(url.url, url.headers);
-              this.fontDescriptors[font].bold = url.url;
-            }
-          }
-          if (this.fontDescriptors[font].italics) {
-            if (Array.isArray(this.fontDescriptors[font].italics)) {
-              // TrueType Collection
-              let url = getExtendedUrl(this.fontDescriptors[font].italics[0]);
-              this.urlResolver.resolve(url.url, url.headers);
-              this.fontDescriptors[font].italics[0] = url.url;
-            } else {
-              let url = getExtendedUrl(this.fontDescriptors[font].italics);
-              this.urlResolver.resolve(url.url, url.headers);
-              this.fontDescriptors[font].italics = url.url;
-            }
-          }
-          if (this.fontDescriptors[font].bolditalics) {
-            if (Array.isArray(this.fontDescriptors[font].bolditalics)) {
-              // TrueType Collection
-              let url = getExtendedUrl(this.fontDescriptors[font].bolditalics[0]);
-              this.urlResolver.resolve(url.url, url.headers);
-              this.fontDescriptors[font].bolditalics[0] = url.url;
-            } else {
-              let url = getExtendedUrl(this.fontDescriptors[font].bolditalics);
-              this.urlResolver.resolve(url.url, url.headers);
-              this.fontDescriptors[font].bolditalics = url.url;
-            }
-          }
-        }
-      }
-      if (docDefinition.images) {
-        for (let image in docDefinition.images) {
-          if (docDefinition.images.hasOwnProperty(image)) {
-            let url = getExtendedUrl(docDefinition.images[image]);
-            this.urlResolver.resolve(url.url, url.headers);
-            docDefinition.images[image] = url.url;
-          }
-        }
-      }
-      if (docDefinition.attachments) {
-        for (let attachment in docDefinition.attachments) {
-          if (docDefinition.attachments.hasOwnProperty(attachment) && docDefinition.attachments[attachment].src) {
-            let url = getExtendedUrl(docDefinition.attachments[attachment].src);
-            this.urlResolver.resolve(url.url, url.headers);
-            docDefinition.attachments[attachment].src = url.url;
-          }
-        }
-      }
-      if (docDefinition.files) {
-        for (let file in docDefinition.files) {
-          if (docDefinition.files.hasOwnProperty(file) && docDefinition.files[file].src) {
-            let url = getExtendedUrl(docDefinition.files[file].src);
-            this.urlResolver.resolve(url.url, url.headers);
-            docDefinition.files[file].src = url.url;
-          }
-        }
-      }
-      this.urlResolver.resolved().then(() => {
-        resolve();
-      }, result => {
-        reject(result);
-      });
-    });
-  }
-}
-function createMetadata(docDefinition) {
-  // PDF standard has these properties reserved: Title, Author, Subject, Keywords,
-  // Creator, Producer, CreationDate, ModDate, Trapped.
-  // To keep the pdfmake api consistent, the info field are defined lowercase.
-  // Custom properties don't contain a space.
-  function standardizePropertyKey(key) {
-    let standardProperties = ['Title', 'Author', 'Subject', 'Keywords', 'Creator', 'Producer', 'CreationDate', 'ModDate', 'Trapped'];
-    let standardizedKey = key.charAt(0).toUpperCase() + key.slice(1);
-    if (standardProperties.includes(standardizedKey)) {
-      return standardizedKey;
-    }
-    return key.replace(/\s+/g, '');
-  }
-  let info = {
-    Producer: 'pdfmake',
-    Creator: 'pdfmake'
-  };
-  if (docDefinition.info) {
-    for (let key in docDefinition.info) {
-      let value = docDefinition.info[key];
-      if (value) {
-        key = standardizePropertyKey(key);
-        info[key] = value;
-      }
-    }
-  }
-  return info;
-}
-function embedFiles(docDefinition, pdfKitDoc) {
-  if (docDefinition.files) {
-    for (const key in docDefinition.files) {
-      const file = docDefinition.files[key];
-      if (!file.src) return;
-      if (pdfKitDoc.virtualfs && pdfKitDoc.virtualfs.existsSync(file.src)) {
-        file.src = pdfKitDoc.virtualfs.readFileSync(file.src);
-      }
-      file.name = file.name || key;
-      pdfKitDoc.file(file.src, file);
-    }
-  }
-}
-function calculatePageHeight(pages, margins) {
-  function getItemHeight(item) {
-    if (typeof item.item.getHeight === 'function') {
-      return item.item.getHeight();
-    } else if (item.item._height) {
-      return item.item._height;
-    } else if (item.type === 'vector') {
-      if (typeof item.item.y1 !== 'undefined') {
-        return item.item.y1 > item.item.y2 ? item.item.y1 : item.item.y2;
-      } else {
-        return item.item.h;
-      }
-    } else {
-      // TODO: add support for next item types
-      return 0;
-    }
-  }
-  function getBottomPosition(item) {
-    let top = item.item.y || 0;
-    let height = getItemHeight(item);
-    return top + height;
-  }
-  let fixedMargins = (0, _PageSize.normalizePageMargin)(margins || 40);
-  let height = fixedMargins.top;
-  pages.forEach(page => {
-    page.items.forEach(item => {
-      let bottomPosition = getBottomPosition(item);
-      if (bottomPosition > height) {
-        height = bottomPosition;
-      }
-    });
-  });
-  height += fixedMargins.bottom;
-  return height;
-}
-var _default = exports.default = PdfPrinter;

package/js/Renderer.js

@@ -1,375 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.default = void 0;
-var _TextDecorator = _interopRequireDefault(require("./TextDecorator"));
-var _TextInlines = _interopRequireDefault(require("./TextInlines"));
-var _variableType = require("./helpers/variableType");
-var _svgToPdfkit = _interopRequireDefault(require("./3rd-party/svg-to-pdfkit"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const findFont = (fonts, requiredFonts, defaultFont) => {
-  for (let i = 0; i < requiredFonts.length; i++) {
-    let requiredFont = requiredFonts[i].toLowerCase();
-    for (let font in fonts) {
-      if (font.toLowerCase() === requiredFont) {
-        return font;
-      }
-    }
-  }
-  return defaultFont;
-};
-
-/**
- * Shift the "y" height of the text baseline up or down (superscript or subscript,
- * respectively). The exact shift can / should be changed according to standard
- * conventions.
- *
- * @param {number} y
- * @param {object} inline
- * @returns {number}
- */
-const offsetText = (y, inline) => {
-  var newY = y;
-  if (inline.sup) {
-    newY -= inline.fontSize * 0.75;
-  }
-  if (inline.sub) {
-    newY += inline.fontSize * 0.35;
-  }
-  return newY;
-};
-class Renderer {
-  constructor(pdfDocument, progressCallback) {
-    this.pdfDocument = pdfDocument;
-    this.progressCallback = progressCallback;
-  }
-  renderPages(pages) {
-    this.pdfDocument._pdfMakePages = pages; // TODO: Why?
-    this.pdfDocument.addPage();
-    let totalItems = 0;
-    if (this.progressCallback) {
-      pages.forEach(page => {
-        totalItems += page.items.length;
-      });
-    }
-    let renderedItems = 0;
-    for (let i = 0; i < pages.length; i++) {
-      if (i > 0) {
-        this._updatePageOrientationInOptions(pages[i]);
-        this.pdfDocument.addPage(this.pdfDocument.options);
-      }
-      let page = pages[i];
-      for (let ii = 0, il = page.items.length; ii < il; ii++) {
-        let item = page.items[ii];
-        switch (item.type) {
-          case 'vector':
-            this.renderVector(item.item);
-            break;
-          case 'line':
-            this.renderLine(item.item, item.item.x, item.item.y);
-            break;
-          case 'image':
-            this.renderImage(item.item);
-            break;
-          case 'svg':
-            this.renderSVG(item.item);
-            break;
-          case 'attachment':
-            this.renderAttachment(item.item);
-            break;
-          case 'beginClip':
-            this.beginClip(item.item);
-            break;
-          case 'endClip':
-            this.endClip();
-            break;
-        }
-        renderedItems++;
-        if (this.progressCallback) {
-          this.progressCallback(renderedItems / totalItems);
-        }
-      }
-      if (page.watermark) {
-        this.renderWatermark(page);
-      }
-    }
-  }
-  renderLine(line, x, y) {
-    function preparePageNodeRefLine(_pageNodeRef, inline) {
-      let newWidth;
-      let diffWidth;
-      let textInlines = new _TextInlines.default(null);
-      if (_pageNodeRef.positions === undefined) {
-        throw new Error('Page reference id not found');
-      }
-      let pageNumber = _pageNodeRef.positions[0].pageNumber.toString();
-      inline.text = pageNumber;
-      newWidth = textInlines.widthOfText(inline.text, inline);
-      diffWidth = inline.width - newWidth;
-      inline.width = newWidth;
-      switch (inline.alignment) {
-        case 'right':
-          inline.x += diffWidth;
-          break;
-        case 'center':
-          inline.x += diffWidth / 2;
-          break;
-      }
-    }
-    if (line._pageNodeRef) {
-      preparePageNodeRefLine(line._pageNodeRef, line.inlines[0]);
-    }
-    x = x || 0;
-    y = y || 0;
-    let lineHeight = line.getHeight();
-    let ascenderHeight = line.getAscenderHeight();
-    let descent = lineHeight - ascenderHeight;
-    const textDecorator = new _TextDecorator.default(this.pdfDocument);
-    textDecorator.drawBackground(line, x, y);
-
-    //TODO: line.optimizeInlines();
-    //TOOD: lines without differently styled inlines should be written to pdf as one stream
-    for (let i = 0, l = line.inlines.length; i < l; i++) {
-      let inline = line.inlines[i];
-      let shiftToBaseline = lineHeight - inline.font.ascender / 1000 * inline.fontSize - descent;
-      if (inline._pageNodeRef) {
-        preparePageNodeRefLine(inline._pageNodeRef, inline);
-      }
-      let options = {
-        lineBreak: false,
-        textWidth: inline.width,
-        characterSpacing: inline.characterSpacing,
-        wordCount: 1,
-        link: inline.link
-      };
-      if (inline.linkToDestination) {
-        options.goTo = inline.linkToDestination;
-      }
-      if (line.id && i === 0) {
-        options.destination = line.id;
-      }
-      if (inline.fontFeatures) {
-        options.features = inline.fontFeatures;
-      }
-      let opacity = (0, _variableType.isNumber)(inline.opacity) ? inline.opacity : 1;
-      this.pdfDocument.opacity(opacity);
-      this.pdfDocument.fill(inline.color || 'black');
-      this.pdfDocument._font = inline.font;
-      this.pdfDocument.fontSize(inline.fontSize);
-      let shiftedY = offsetText(y + shiftToBaseline, inline);
-      this.pdfDocument.text(inline.text, x + inline.x, shiftedY, options);
-      if (inline.linkToPage) {
-        this.pdfDocument.ref({
-          Type: 'Action',
-          S: 'GoTo',
-          D: [inline.linkToPage, 0, 0]
-        }).end();
-        this.pdfDocument.annotate(x + inline.x, shiftedY, inline.width, inline.height, {
-          Subtype: 'Link',
-          Dest: [inline.linkToPage - 1, 'XYZ', null, null, null]
-        });
-      }
-    }
-
-    // Decorations won't draw correctly for superscript
-    textDecorator.drawDecorations(line, x, y);
-  }
-  renderVector(vector) {
-    //TODO: pdf optimization (there's no need to write all properties everytime)
-    this.pdfDocument.lineWidth(vector.lineWidth || 1);
-    if (vector.dash) {
-      this.pdfDocument.dash(vector.dash.length, {
-        space: vector.dash.space || vector.dash.length,
-        phase: vector.dash.phase || 0
-      });
-    } else {
-      this.pdfDocument.undash();
-    }
-    this.pdfDocument.lineJoin(vector.lineJoin || 'miter');
-    this.pdfDocument.lineCap(vector.lineCap || 'butt');
-
-    //TODO: clipping
-
-    let gradient = null;
-    switch (vector.type) {
-      case 'ellipse':
-        this.pdfDocument.ellipse(vector.x, vector.y, vector.r1, vector.r2);
-        if (vector.linearGradient) {
-          gradient = this.pdfDocument.linearGradient(vector.x - vector.r1, vector.y, vector.x + vector.r1, vector.y);
-        }
-        break;
-      case 'rect':
-        if (vector.r) {
-          this.pdfDocument.roundedRect(vector.x, vector.y, vector.w, vector.h, vector.r);
-        } else {
-          this.pdfDocument.rect(vector.x, vector.y, vector.w, vector.h);
-        }
-        if (vector.linearGradient) {
-          gradient = this.pdfDocument.linearGradient(vector.x, vector.y, vector.x + vector.w, vector.y);
-        }
-        break;
-      case 'line':
-        this.pdfDocument.moveTo(vector.x1, vector.y1);
-        this.pdfDocument.lineTo(vector.x2, vector.y2);
-        break;
-      case 'polyline':
-        if (vector.points.length === 0) {
-          break;
-        }
-        this.pdfDocument.moveTo(vector.points[0].x, vector.points[0].y);
-        for (let i = 1, l = vector.points.length; i < l; i++) {
-          this.pdfDocument.lineTo(vector.points[i].x, vector.points[i].y);
-        }
-        if (vector.points.length > 1) {
-          let p1 = vector.points[0];
-          let pn = vector.points[vector.points.length - 1];
-          if (vector.closePath || p1.x === pn.x && p1.y === pn.y) {
-            this.pdfDocument.closePath();
-          }
-        }
-        break;
-      case 'path':
-        this.pdfDocument.path(vector.d);
-        break;
-    }
-    if (vector.linearGradient && gradient) {
-      let step = 1 / (vector.linearGradient.length - 1);
-      for (let i = 0; i < vector.linearGradient.length; i++) {
-        gradient.stop(i * step, vector.linearGradient[i]);
-      }
-      vector.color = gradient;
-    }
-    let patternColor = this.pdfDocument.providePattern(vector.color);
-    if (patternColor !== null) {
-      vector.color = patternColor;
-    }
-    let fillOpacity = (0, _variableType.isNumber)(vector.fillOpacity) ? vector.fillOpacity : 1;
-    let strokeOpacity = (0, _variableType.isNumber)(vector.strokeOpacity) ? vector.strokeOpacity : 1;
-    if (vector.color && vector.lineColor) {
-      this.pdfDocument.fillColor(vector.color, fillOpacity);
-      this.pdfDocument.strokeColor(vector.lineColor, strokeOpacity);
-      this.pdfDocument.fillAndStroke();
-    } else if (vector.color) {
-      this.pdfDocument.fillColor(vector.color, fillOpacity);
-      this.pdfDocument.fill();
-    } else {
-      this.pdfDocument.strokeColor(vector.lineColor || 'black', strokeOpacity);
-      this.pdfDocument.stroke();
-    }
-  }
-  renderImage(image) {
-    let opacity = (0, _variableType.isNumber)(image.opacity) ? image.opacity : 1;
-    this.pdfDocument.opacity(opacity);
-    if (image.cover) {
-      const align = image.cover.align || 'center';
-      const valign = image.cover.valign || 'center';
-      const width = image.cover.width ? image.cover.width : image.width;
-      const height = image.cover.height ? image.cover.height : image.height;
-      this.pdfDocument.save();
-      this.pdfDocument.rect(image.x, image.y, width, height).clip();
-      this.pdfDocument.image(image.image, image.x, image.y, {
-        cover: [width, height],
-        align: align,
-        valign: valign
-      });
-      this.pdfDocument.restore();
-    } else {
-      this.pdfDocument.image(image.image, image.x, image.y, {
-        width: image._width,
-        height: image._height
-      });
-    }
-    if (image.link) {
-      this.pdfDocument.link(image.x, image.y, image._width, image._height, image.link);
-    }
-    if (image.linkToPage) {
-      this.pdfDocument.ref({
-        Type: 'Action',
-        S: 'GoTo',
-        D: [image.linkToPage, 0, 0]
-      }).end();
-      this.pdfDocument.annotate(image.x, image.y, image._width, image._height, {
-        Subtype: 'Link',
-        Dest: [image.linkToPage - 1, 'XYZ', null, null, null]
-      });
-    }
-    if (image.linkToDestination) {
-      this.pdfDocument.goTo(image.x, image.y, image._width, image._height, image.linkToDestination);
-    }
-    if (image.linkToFile) {
-      const attachment = this.pdfDocument.provideAttachment(image.linkToFile);
-      this.pdfDocument.fileAnnotation(image.x, image.y, image._width, image._height, attachment,
-      // add empty rectangle as file annotation appearance with the same size as the rendered image
-      {
-        AP: {
-          N: {
-            Type: 'XObject',
-            Subtype: 'Form',
-            FormType: 1,
-            BBox: [image.x, image.y, image._width, image._height]
-          }
-        }
-      });
-    }
-  }
-  renderSVG(svg) {
-    let options = Object.assign({
-      width: svg._width,
-      height: svg._height,
-      assumePt: true
-    }, svg.options);
-    options.fontCallback = (family, bold, italic) => {
-      let fontsFamily = family.split(',').map(f => f.trim().replace(/('|")/g, ''));
-      let font = findFont(this.pdfDocument.fonts, fontsFamily, svg.font || 'Roboto');
-      let fontFile = this.pdfDocument.getFontFile(font, bold, italic);
-      if (fontFile === null) {
-        let type = this.pdfDocument.getFontType(bold, italic);
-        throw new Error(`Font '${font}' in style '${type}' is not defined in the font section of the document definition.`);
-      }
-      return fontFile;
-    };
-    (0, _svgToPdfkit.default)(this.pdfDocument, svg.svg, svg.x, svg.y, options);
-  }
-  renderAttachment(attachment) {
-    const file = this.pdfDocument.provideAttachment(attachment.attachment);
-    const options = {};
-    if (attachment.icon) {
-      options.Name = attachment.icon;
-    }
-    this.pdfDocument.fileAnnotation(attachment.x, attachment.y, attachment._width, attachment._height, file, options);
-  }
-  beginClip(rect) {
-    this.pdfDocument.save();
-    this.pdfDocument.addContent(`${rect.x} ${rect.y} ${rect.width} ${rect.height} re`);
-    this.pdfDocument.clip();
-  }
-  endClip() {
-    this.pdfDocument.restore();
-  }
-  renderWatermark(page) {
-    let watermark = page.watermark;
-    this.pdfDocument.fill(watermark.color);
-    this.pdfDocument.opacity(watermark.opacity);
-    this.pdfDocument.save();
-    this.pdfDocument.rotate(watermark.angle, {
-      origin: [this.pdfDocument.page.width / 2, this.pdfDocument.page.height / 2]
-    });
-    let x = this.pdfDocument.page.width / 2 - watermark._size.size.width / 2;
-    let y = this.pdfDocument.page.height / 2 - watermark._size.size.height / 2;
-    this.pdfDocument._font = watermark.font;
-    this.pdfDocument.fontSize(watermark.fontSize);
-    this.pdfDocument.text(watermark.text, x, y, {
-      lineBreak: false
-    });
-    this.pdfDocument.restore();
-  }
-  _updatePageOrientationInOptions(currentPage) {
-    let previousPageOrientation = this.pdfDocument.options.size[0] > this.pdfDocument.options.size[1] ? 'landscape' : 'portrait';
-    if (currentPage.pageSize.orientation !== previousPageOrientation) {
-      let width = this.pdfDocument.options.size[0];
-      let height = this.pdfDocument.options.size[1];
-      this.pdfDocument.options.size = [height, width];
-    }
-  }
-}
-var _default = exports.default = Renderer;