pdfmake 0.3.0-beta.8 → 0.3.0

package/js/TextBreaker.js

@@ -0,0 +1,166 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _linebreak = _interopRequireDefault(require("linebreak"));
+var _variableType = require("./helpers/variableType");
+var _StyleContextStack = _interopRequireDefault(require("./StyleContextStack"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * @param {string} text
+ * @param {boolean} noWrap
+ * @param {boolean} breakAll
+ * @returns {Array}
+ */
+const splitWords = (text, noWrap, breakAll = false) => {
+  let words = [];
+  if (text === undefined || text === null) {
+    text = '';
+  } else {
+    text = String(text);
+  }
+  if (noWrap) {
+    words.push({
+      text: text
+    });
+    return words;
+  }
+  if (breakAll) {
+    return text.split('').map(c => {
+      if (c.match(/^\n$|^\r$/)) {
+        // new line
+        return {
+          text: '',
+          lineEnd: true
+        };
+      }
+      return {
+        text: c
+      };
+    });
+  }
+  if (text.length === 0) {
+    words.push({
+      text: ''
+    });
+    return words;
+  }
+  let breaker = new _linebreak.default(text);
+  let last = 0;
+  let bk;
+  while (bk = breaker.nextBreak()) {
+    let word = text.slice(last, bk.position);
+    if (bk.required || word.match(/\r?\n$|\r$/)) {
+      // new line
+      word = word.replace(/\r?\n$|\r$/, '');
+      words.push({
+        text: word,
+        lineEnd: true
+      });
+    } else {
+      words.push({
+        text: word
+      });
+    }
+    last = bk.position;
+  }
+  return words;
+};
+
+/**
+ * @param {Array} words
+ * @param {boolean} noWrap
+ * @returns {?string}
+ */
+const getFirstWord = (words, noWrap) => {
+  let word = words[0];
+  if (word === undefined) {
+    return null;
+  }
+  if (noWrap) {
+    // text was not wrapped, we need only first word
+    let tmpWords = splitWords(word.text, false);
+    if (tmpWords[0] === undefined) {
+      return null;
+    }
+    word = tmpWords[0];
+  }
+  return word.text;
+};
+
+/**
+ * @param {Array} words
+ * @param {boolean} noWrap
+ * @returns {?string}
+ */
+const getLastWord = (words, noWrap) => {
+  let word = words[words.length - 1];
+  if (word === undefined) {
+    return null;
+  }
+  if (word.lineEnd) {
+    return null;
+  }
+  if (noWrap) {
+    // text was not wrapped, we need only last word
+    let tmpWords = splitWords(word.text, false);
+    if (tmpWords[tmpWords.length - 1] === undefined) {
+      return null;
+    }
+    word = tmpWords[tmpWords.length - 1];
+  }
+  return word.text;
+};
+class TextBreaker {
+  /**
+   * @param {string|Array} texts
+   * @param {StyleContextStack} styleContextStack
+   * @returns {Array}
+   */
+  getBreaks(texts, styleContextStack) {
+    let results = [];
+    if (!Array.isArray(texts)) {
+      texts = [texts];
+    }
+    let lastWord = null;
+    for (let i = 0, l = texts.length; i < l; i++) {
+      let item = texts[i];
+      let style = null;
+      let words;
+      let breakAll = _StyleContextStack.default.getStyleProperty(item || {}, styleContextStack, 'wordBreak', 'normal') === 'break-all';
+      let noWrap = _StyleContextStack.default.getStyleProperty(item || {}, styleContextStack, 'noWrap', false);
+      if ((0, _variableType.isObject)(item)) {
+        if (item._textRef && item._textRef._textNodeRef.text) {
+          item.text = item._textRef._textNodeRef.text;
+        }
+        words = splitWords(item.text, noWrap, breakAll);
+        style = _StyleContextStack.default.copyStyle(item);
+      } else {
+        words = splitWords(item, noWrap, breakAll);
+      }
+      if (lastWord && words.length) {
+        let firstWord = getFirstWord(words, noWrap);
+        let wrapWords = splitWords(lastWord + firstWord, false);
+        if (wrapWords.length === 1) {
+          results[results.length - 1].noNewLine = true;
+        }
+      }
+      for (let i2 = 0, l2 = words.length; i2 < l2; i2++) {
+        let result = {
+          text: words[i2].text
+        };
+        if (words[i2].lineEnd) {
+          result.lineEnd = true;
+        }
+        _StyleContextStack.default.copyStyle(style, result);
+        results.push(result);
+      }
+      lastWord = null;
+      if (i + 1 < l) {
+        lastWord = getLastWord(words, noWrap);
+      }
+    }
+    return results;
+  }
+}
+var _default = exports.default = TextBreaker;

package/js/TextDecorator.js

@@ -0,0 +1,143 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+const groupDecorations = line => {
+  let groups = [];
+  let currentGroup = null;
+  for (let i = 0, l = line.inlines.length; i < l; i++) {
+    let inline = line.inlines[i];
+    let decoration = inline.decoration;
+    if (!decoration) {
+      currentGroup = null;
+      continue;
+    }
+    if (!Array.isArray(decoration)) {
+      decoration = [decoration];
+    }
+    let color = inline.decorationColor || inline.color || 'black';
+    let style = inline.decorationStyle || 'solid';
+    for (let ii = 0, ll = decoration.length; ii < ll; ii++) {
+      let decorationItem = decoration[ii];
+      if (!currentGroup || decorationItem !== currentGroup.decoration || style !== currentGroup.decorationStyle || color !== currentGroup.decorationColor) {
+        currentGroup = {
+          line: line,
+          decoration: decorationItem,
+          decorationColor: color,
+          decorationStyle: style,
+          inlines: [inline]
+        };
+        groups.push(currentGroup);
+      } else {
+        currentGroup.inlines.push(inline);
+      }
+    }
+  }
+  return groups;
+};
+class TextDecorator {
+  constructor(pdfDocument) {
+    this.pdfDocument = pdfDocument;
+  }
+  drawBackground(line, x, y) {
+    let height = line.getHeight();
+    for (let i = 0, l = line.inlines.length; i < l; i++) {
+      let inline = line.inlines[i];
+      if (!inline.background) {
+        continue;
+      }
+      let color = inline.background;
+      let patternColor = this.pdfDocument.providePattern(inline.background);
+      if (patternColor !== null) {
+        color = patternColor;
+      }
+      let justifyShift = inline.justifyShift || 0;
+      this.pdfDocument.fillColor(color).rect(x + inline.x - justifyShift, y, inline.width + justifyShift, height).fill();
+    }
+  }
+  drawDecorations(line, x, y) {
+    let groups = groupDecorations(line);
+    for (let i = 0, l = groups.length; i < l; i++) {
+      this._drawDecoration(groups[i], x, y);
+    }
+  }
+  _drawDecoration(group, x, y) {
+    const maxInline = () => {
+      let max = 0;
+      for (let i = 0, l = group.inlines.length; i < l; i++) {
+        let inline = group.inlines[i];
+        max = inline.fontSize > max ? i : max;
+      }
+      return group.inlines[max];
+    };
+    const width = () => {
+      let sum = 0;
+      for (let i = 0, l = group.inlines.length; i < l; i++) {
+        let justifyShift = group.inlines[i].justifyShift || 0;
+        sum += group.inlines[i].width + justifyShift;
+      }
+      return sum;
+    };
+    let firstInline = group.inlines[0];
+    let biggerInline = maxInline();
+    let totalWidth = width();
+    let lineAscent = group.line.getAscenderHeight();
+    let ascent = biggerInline.font.ascender / 1000 * biggerInline.fontSize;
+    let height = biggerInline.height;
+    let descent = height - ascent;
+    let lw = 0.5 + Math.floor(Math.max(biggerInline.fontSize - 8, 0) / 2) * 0.12;
+    switch (group.decoration) {
+      case 'underline':
+        y += lineAscent + descent * 0.45;
+        break;
+      case 'overline':
+        y += lineAscent - ascent * 0.85;
+        break;
+      case 'lineThrough':
+        y += lineAscent - ascent * 0.25;
+        break;
+      default:
+        throw new Error(`Unknown decoration : ${group.decoration}`);
+    }
+    this.pdfDocument.save();
+    if (group.decorationStyle === 'double') {
+      let gap = Math.max(0.5, lw * 2);
+      this.pdfDocument.fillColor(group.decorationColor).rect(x + firstInline.x, y - lw / 2, totalWidth, lw / 2).fill().rect(x + firstInline.x, y + gap - lw / 2, totalWidth, lw / 2).fill();
+    } else if (group.decorationStyle === 'dashed') {
+      let nbDashes = Math.ceil(totalWidth / (3.96 + 2.84));
+      let rdx = x + firstInline.x;
+      this.pdfDocument.rect(rdx, y, totalWidth, lw).clip();
+      this.pdfDocument.fillColor(group.decorationColor);
+      for (let i = 0; i < nbDashes; i++) {
+        this.pdfDocument.rect(rdx, y - lw / 2, 3.96, lw).fill();
+        rdx += 3.96 + 2.84;
+      }
+    } else if (group.decorationStyle === 'dotted') {
+      let nbDots = Math.ceil(totalWidth / (lw * 3));
+      let rx = x + firstInline.x;
+      this.pdfDocument.rect(rx, y, totalWidth, lw).clip();
+      this.pdfDocument.fillColor(group.decorationColor);
+      for (let i = 0; i < nbDots; i++) {
+        this.pdfDocument.rect(rx, y - lw / 2, lw, lw).fill();
+        rx += lw * 3;
+      }
+    } else if (group.decorationStyle === 'wavy') {
+      let sh = 0.7,
+        sv = 1;
+      let nbWaves = Math.ceil(totalWidth / (sh * 2)) + 1;
+      let rwx = x + firstInline.x - 1;
+      this.pdfDocument.rect(x + firstInline.x, y - sv, totalWidth, y + sv).clip();
+      this.pdfDocument.lineWidth(0.24);
+      this.pdfDocument.moveTo(rwx, y);
+      for (let i = 0; i < nbWaves; i++) {
+        this.pdfDocument.bezierCurveTo(rwx + sh, y - sv, rwx + sh * 2, y - sv, rwx + sh * 3, y).bezierCurveTo(rwx + sh * 4, y + sv, rwx + sh * 5, y + sv, rwx + sh * 6, y);
+        rwx += sh * 6;
+      }
+      this.pdfDocument.stroke(group.decorationColor);
+    } else {
+      this.pdfDocument.fillColor(group.decorationColor).rect(x + firstInline.x, y - lw / 2, totalWidth, lw).fill();
+    }
+    this.pdfDocument.restore();
+  }
+}
+var _default = exports.default = TextDecorator;

package/js/TextInlines.js

@@ -0,0 +1,206 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _TextBreaker = _interopRequireDefault(require("./TextBreaker"));
+var _StyleContextStack = _interopRequireDefault(require("./StyleContextStack"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const LEADING = /^(\s)+/g;
+const TRAILING = /(\s)+$/g;
+
+/**
+ * @param {Array} array
+ * @returns {Array}
+ */
+const flattenTextArray = array => {
+  function flatten(array) {
+    return array.reduce((prev, cur) => {
+      let current = Array.isArray(cur.text) ? flatten(cur.text) : cur;
+      let more = [].concat(current).some(Array.isArray);
+      return prev.concat(more ? flatten(current) : current);
+    }, []);
+  }
+  if (!Array.isArray(array)) {
+    array = [array];
+  }
+
+  // TODO: Styling in nested text (issue: https://github.com/bpampuch/pdfmake/issues/1174)
+
+  array = flatten(array);
+  return array;
+};
+
+/**
+ * Text measurement utility
+ */
+class TextInlines {
+  /**
+   * @param {object} pdfDocument object is instance of PDFDocument
+   */
+  constructor(pdfDocument) {
+    this.pdfDocument = pdfDocument;
+  }
+
+  /**
+   * Converts an array of strings (or inline-definition-objects) into a collection
+   * of inlines and calculated minWidth/maxWidth and their min/max widths
+   *
+   * @param {Array|object} textArray an array of inline-definition-objects (or strings)
+   * @param {StyleContextStack} styleContextStack current style stack
+   * @returns {object} collection of inlines, minWidth, maxWidth
+   */
+  buildInlines(textArray, styleContextStack) {
+    const getTrimmedWidth = item => {
+      return Math.max(0, item.width - item.leadingCut - item.trailingCut);
+    };
+    let minWidth = 0;
+    let maxWidth = 0;
+    let currentLineWidth;
+    let flattenedTextArray = flattenTextArray(textArray);
+    const textBreaker = new _TextBreaker.default();
+    let breakedText = textBreaker.getBreaks(flattenedTextArray, styleContextStack);
+    let measuredText = this.measure(breakedText, styleContextStack);
+    measuredText.forEach(inline => {
+      minWidth = Math.max(minWidth, getTrimmedWidth(inline));
+      if (!currentLineWidth) {
+        currentLineWidth = {
+          width: 0,
+          leadingCut: inline.leadingCut,
+          trailingCut: 0
+        };
+      }
+      currentLineWidth.width += inline.width;
+      currentLineWidth.trailingCut = inline.trailingCut;
+      maxWidth = Math.max(maxWidth, getTrimmedWidth(currentLineWidth));
+      if (inline.lineEnd) {
+        currentLineWidth = null;
+      }
+    });
+    if (_StyleContextStack.default.getStyleProperty({}, styleContextStack, 'noWrap', false)) {
+      minWidth = maxWidth;
+    }
+    return {
+      items: measuredText,
+      minWidth: minWidth,
+      maxWidth: maxWidth
+    };
+  }
+  measure(array, styleContextStack) {
+    if (array.length) {
+      let leadingIndent = _StyleContextStack.default.getStyleProperty(array[0], styleContextStack, 'leadingIndent', 0);
+      if (leadingIndent) {
+        array[0].leadingCut = -leadingIndent;
+        array[0].leadingIndent = leadingIndent;
+      }
+    }
+    array.forEach(item => {
+      let font = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'font', 'Roboto');
+      let bold = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'bold', false);
+      let italics = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'italics', false);
+      item.font = this.pdfDocument.provideFont(font, bold, italics);
+      item.alignment = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'alignment', 'left');
+      item.fontSize = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'fontSize', 12);
+      item.fontFeatures = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'fontFeatures', null);
+      item.characterSpacing = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'characterSpacing', 0);
+      item.color = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'color', 'black');
+      item.decoration = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'decoration', null);
+      item.decorationColor = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'decorationColor', null);
+      item.decorationStyle = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'decorationStyle', null);
+      item.background = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'background', null);
+      item.link = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'link', null);
+      item.linkToPage = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'linkToPage', null);
+      item.linkToDestination = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'linkToDestination', null);
+      item.noWrap = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'noWrap', null);
+      item.opacity = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'opacity', 1);
+      item.sup = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'sup', false);
+      item.sub = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'sub', false);
+      if (item.sup || item.sub) {
+        // font size reduction taken from here: https://en.wikipedia.org/wiki/Subscript_and_superscript#Desktop_publishing
+        item.fontSize *= 0.58;
+      }
+      let lineHeight = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'lineHeight', 1);
+      item.width = this.widthOfText(item.text, item);
+      item.height = item.font.lineHeight(item.fontSize) * lineHeight;
+      if (!item.leadingCut) {
+        item.leadingCut = 0;
+      }
+      let preserveLeadingSpaces = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'preserveLeadingSpaces', false);
+      if (!preserveLeadingSpaces) {
+        let leadingSpaces = item.text.match(LEADING);
+        if (leadingSpaces) {
+          item.leadingCut += this.widthOfText(leadingSpaces[0], item);
+        }
+      }
+      item.trailingCut = 0;
+      let preserveTrailingSpaces = _StyleContextStack.default.getStyleProperty(item, styleContextStack, 'preserveTrailingSpaces', false);
+      if (!preserveTrailingSpaces) {
+        let trailingSpaces = item.text.match(TRAILING);
+        if (trailingSpaces) {
+          item.trailingCut = this.widthOfText(trailingSpaces[0], item);
+        }
+      }
+    }, this);
+    return array;
+  }
+
+  /**
+   * Width of text
+   *
+   * @param {string} text
+   * @param {object} inline
+   * @returns {number}
+   */
+  widthOfText(text, inline) {
+    return inline.font.widthOfString(text, inline.fontSize, inline.fontFeatures) + (inline.characterSpacing || 0) * (text.length - 1);
+  }
+
+  /**
+   * Returns size of the specified string (without breaking it) using the current style
+   *
+   * @param {string} text text to be measured
+   * @param {object} styleContextStack current style stack
+   * @returns {object} size of the specified string
+   */
+  sizeOfText(text, styleContextStack) {
+    //TODO: refactor - extract from measure
+    let fontName = _StyleContextStack.default.getStyleProperty({}, styleContextStack, 'font', 'Roboto');
+    let fontSize = _StyleContextStack.default.getStyleProperty({}, styleContextStack, 'fontSize', 12);
+    let fontFeatures = _StyleContextStack.default.getStyleProperty({}, styleContextStack, 'fontFeatures', null);
+    let bold = _StyleContextStack.default.getStyleProperty({}, styleContextStack, 'bold', false);
+    let italics = _StyleContextStack.default.getStyleProperty({}, styleContextStack, 'italics', false);
+    let lineHeight = _StyleContextStack.default.getStyleProperty({}, styleContextStack, 'lineHeight', 1);
+    let characterSpacing = _StyleContextStack.default.getStyleProperty({}, styleContextStack, 'characterSpacing', 0);
+    let font = this.pdfDocument.provideFont(fontName, bold, italics);
+    return {
+      width: this.widthOfText(text, {
+        font: font,
+        fontSize: fontSize,
+        characterSpacing: characterSpacing,
+        fontFeatures: fontFeatures
+      }),
+      height: font.lineHeight(fontSize) * lineHeight,
+      fontSize: fontSize,
+      lineHeight: lineHeight,
+      ascender: font.ascender / 1000 * fontSize,
+      descender: font.descender / 1000 * fontSize
+    };
+  }
+
+  /**
+   * Returns size of the specified rotated string (without breaking it) using the current style
+   *
+   * @param {string} text text to be measured
+   * @param {number} angle
+   * @param {object} styleContextStack current style stack
+   * @returns {object} size of the specified string
+   */
+  sizeOfRotatedText(text, angle, styleContextStack) {
+    let angleRad = angle * Math.PI / -180;
+    let size = this.sizeOfText(text, styleContextStack);
+    return {
+      width: Math.abs(size.height * Math.sin(angleRad)) + Math.abs(size.width * Math.cos(angleRad)),
+      height: Math.abs(size.width * Math.sin(angleRad)) + Math.abs(size.height * Math.cos(angleRad))
+    };
+  }
+}
+var _default = exports.default = TextInlines;

package/js/URLResolver.js

@@ -0,0 +1,43 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+async function fetchUrl(url, headers = {}) {
+  try {
+    const response = await fetch(url, {
+      headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch (status code: ${response.status}, url: "${url}")`);
+    }
+    return await response.arrayBuffer();
+  } catch (error) {
+    throw new Error(`Network request failed (url: "${url}", error: ${error.message})`);
+  }
+}
+class URLResolver {
+  constructor(fs) {
+    this.fs = fs;
+    this.resolving = {};
+  }
+  resolve(url, headers = {}) {
+    const resolveUrlInternal = async () => {
+      if (url.toLowerCase().startsWith('https://') || url.toLowerCase().startsWith('http://')) {
+        if (this.fs.existsSync(url)) {
+          return; // url was downloaded earlier
+        }
+        const buffer = await fetchUrl(url, headers);
+        this.fs.writeFileSync(url, buffer);
+      }
+      // else cannot be resolved
+    };
+    if (!this.resolving[url]) {
+      this.resolving[url] = resolveUrlInternal();
+    }
+    return this.resolving[url];
+  }
+  resolved() {
+    return Promise.all(Object.values(this.resolving));
+  }
+}
+var _default = exports.default = URLResolver;

package/js/base.js

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _Printer = _interopRequireDefault(require("./Printer"));
+var _virtualFs = _interopRequireDefault(require("./virtual-fs"));
+var _tools = require("./helpers/tools");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class pdfmake {
+  constructor() {
+    this.virtualfs = _virtualFs.default;
+    this.urlResolver = null;
+  }
+
+  /**
+   * @param {object} docDefinition
+   * @param {?object} options
+   * @returns {object}
+   */
+  createPdf(docDefinition, options = {}) {
+    options.progressCallback = this.progressCallback;
+    options.tableLayouts = this.tableLayouts;
+    let printer = new _Printer.default(this.fonts, this.virtualfs, this.urlResolver());
+    const pdfDocumentPromise = printer.createPdfKitDocument(docDefinition, options);
+    return this._transformToDocument(pdfDocumentPromise);
+  }
+  setProgressCallback(callback) {
+    this.progressCallback = callback;
+  }
+  addTableLayouts(tableLayouts) {
+    this.tableLayouts = (0, _tools.pack)(this.tableLayouts, tableLayouts);
+  }
+  setTableLayouts(tableLayouts) {
+    this.tableLayouts = tableLayouts;
+  }
+  clearTableLayouts() {
+    this.tableLayouts = {};
+  }
+  addFonts(fonts) {
+    this.fonts = (0, _tools.pack)(this.fonts, fonts);
+  }
+  setFonts(fonts) {
+    this.fonts = fonts;
+  }
+  clearFonts() {
+    this.fonts = {};
+  }
+  _transformToDocument(doc) {
+    return doc;
+  }
+}
+var _default = exports.default = pdfmake;

package/js/browser-extensions/OutputDocumentBrowser.js

@@ -0,0 +1,81 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _OutputDocument = _interopRequireDefault(require("../OutputDocument"));
+var _fileSaver = require("file-saver");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * @returns {Window}
+ */
+const openWindow = () => {
+  // we have to open the window immediately and store the reference
+  // otherwise popup blockers will stop us
+  let win = window.open('', '_blank');
+  if (win === null) {
+    throw new Error('Open PDF in new window blocked by browser');
+  }
+  return win;
+};
+class OutputDocumentBrowser extends _OutputDocument.default {
+  /**
+   * @returns {Promise<Blob>}
+   */
+  async getBlob() {
+    const buffer = await this.getBuffer();
+    return new Blob([buffer], {
+      type: 'application/pdf'
+    });
+  }
+
+  /**
+   * @param {string} filename
+   * @returns {Promise}
+   */
+  async download(filename = 'file.pdf') {
+    const blob = await this.getBlob();
+    (0, _fileSaver.saveAs)(blob, filename);
+  }
+
+  /**
+   * @param {Window} win
+   * @returns {Promise}
+   */
+  async open(win = null) {
+    if (!win) {
+      win = openWindow();
+    }
+    const blob = await this.getBlob();
+    try {
+      let urlCreator = window.URL || window.webkitURL;
+      let pdfUrl = urlCreator.createObjectURL(blob);
+      win.location.href = pdfUrl;
+
+      /* temporarily disabled
+      if (win === window) {
+      	return;
+      } else {
+      	setTimeout(() => {
+      		if (win.window === null) { // is closed by AdBlock
+      			window.location.href = pdfUrl; // open in actual window
+      		}
+      		return;
+      	}, 500);
+      }
+      */
+    } finally {
+      win.close();
+    }
+  }
+
+  /**
+   * @param {Window} win
+   * @returns {Promise}
+   */
+  async print(win = null) {
+    const stream = await this.getStream();
+    stream.setOpenActionAsPrint();
+    await this.open(win);
+  }
+}
+var _default = exports.default = OutputDocumentBrowser;