modules/html.js

  1. /**
  2.  * @license
  3.  * Copyright (c) 2018 Erik Koopmans
  4.  * Released under the MIT License.
  5.  *
  6.  * Licensed under the MIT License.
  7.  * http://opensource.org/licenses/mit-license
  8.  */
  10. import { jsPDF } from "../jspdf.js";
  11. import { normalizeFontFace } from "../libs/fontFace.js";
  12. import { globalObject } from "../libs/globalObject.js";
  14. /**
  15.  * jsPDF html PlugIn
  16.  *
  17.  * @name html
  18.  * @module
  19.  */
  20. (function(jsPDFAPI) {
  21.   "use strict";
  23.   function loadHtml2Canvas() {
  24.     return (function() {
  25.       if (globalObject["html2canvas"]) {
  26.         return Promise.resolve(globalObject["html2canvas"]);
  27.       }
  29.       // @if MODULE_FORMAT='es'
  30.       return import("html2canvas");
  31.       // @endif
  33.       // @if MODULE_FORMAT!='es'
  34.       if (typeof exports === "object" && typeof module !== "undefined") {
  35.         return new Promise(function(resolve, reject) {
  36.           try {
  37.             resolve(require("html2canvas"));
  38.           } catch (e) {
  39.             reject(e);
  40.           }
  41.         });
  42.       }
  43.       if (typeof define === "function" && define.amd) {
  44.         return new Promise(function(resolve, reject) {
  45.           try {
  46.             require(["html2canvas"], resolve);
  47.           } catch (e) {
  48.             reject(e);
  49.           }
  50.         });
  51.       }
  52.       return Promise.reject(new Error("Could not load html2canvas"));
  53.       // @endif
  54.     })()
  55.       .catch(function(e) {
  56.         return Promise.reject(new Error("Could not load html2canvas: " + e));
  57.       })
  58.       .then(function(html2canvas) {
  59.         return html2canvas.default ? html2canvas.default : html2canvas;
  60.       });
  61.   }
  63.   function loadDomPurify() {
  64.     return (function() {
  65.       if (globalObject["DOMPurify"]) {
  66.         return Promise.resolve(globalObject["DOMPurify"]);
  67.       }
  69.       // @if MODULE_FORMAT='es'
  70.       return import("dompurify");
  71.       // @endif
  73.       // @if MODULE_FORMAT!='es'
  74.       if (typeof exports === "object" && typeof module !== "undefined") {
  75.         return new Promise(function(resolve, reject) {
  76.           try {
  77.             resolve(require("dompurify"));
  78.           } catch (e) {
  79.             reject(e);
  80.           }
  81.         });
  82.       }
  83.       if (typeof define === "function" && define.amd) {
  84.         return new Promise(function(resolve, reject) {
  85.           try {
  86.             require(["dompurify"], resolve);
  87.           } catch (e) {
  88.             reject(e);
  89.           }
  90.         });
  91.       }
  92.       return Promise.reject(new Error("Could not load dompurify"));
  93.       // @endif
  94.     })()
  95.       .catch(function(e) {
  96.         return Promise.reject(new Error("Could not load dompurify: " + e));
  97.       })
  98.       .then(function(dompurify) {
  99.         return dompurify.default ? dompurify.default : dompurify;
  100.       });
  101.   }
  103.   /**
  104.    * Determine the type of a variable/object.
  105.    *
  106.    * @private
  107.    * @ignore
  108.    */
  109.   var objType = function(obj) {
  110.     var type = typeof obj;
  111.     if (type === "undefined") return "undefined";
  112.     else if (type === "string" || obj instanceof String) return "string";
  113.     else if (type === "number" || obj instanceof Number) return "number";
  114.     else if (type === "function" || obj instanceof Function) return "function";
  115.     else if (!!obj && obj.constructor === Array) return "array";
  116.     else if (obj && obj.nodeType === 1) return "element";
  117.     else if (type === "object") return "object";
  118.     else return "unknown";
  119.   };
  121.   /**
  122.    * Create an HTML element with optional className, innerHTML, and style.
  123.    *
  124.    * @private
  125.    * @ignore
  126.    */
  127.   var createElement = function(tagName, opt) {
  128.     var el = document.createElement(tagName);
  129.     if (opt.className) el.className = opt.className;
  130.     if (opt.innerHTML && opt.dompurify) {
  131.       el.innerHTML = opt.dompurify.sanitize(opt.innerHTML);
  132.     }
  133.     for (var key in opt.style) {
  134.       el.style[key] = opt.style[key];
  135.     }
  136.     return el;
  137.   };
  139.   /**
  140.    * Deep-clone a node and preserve contents/properties.
  141.    *
  142.    * @private
  143.    * @ignore
  144.    */
  145.   var cloneNode = function(node, javascriptEnabled) {
  146.     // Recursively clone the node.
  147.     var clone =
  148.       node.nodeType === 3
  149.         ? document.createTextNode(node.nodeValue)
  150.         : node.cloneNode(false);
  151.     for (var child = node.firstChild; child; child = child.nextSibling) {
  152.       if (
  153.         javascriptEnabled === true ||
  154.         child.nodeType !== 1 ||
  155.         child.nodeName !== "SCRIPT"
  156.       ) {
  157.         clone.appendChild(cloneNode(child, javascriptEnabled));
  158.       }
  159.     }
  161.     if (node.nodeType === 1) {
  162.       // Preserve contents/properties of special nodes.
  163.       if (node.nodeName === "CANVAS") {
  164.         clone.width = node.width;
  165.         clone.height = node.height;
  166.         clone.getContext("2d").drawImage(node, 0, 0);
  167.       } else if (node.nodeName === "TEXTAREA" || node.nodeName === "SELECT") {
  168.         clone.value = node.value;
  169.       }
  171.       // Preserve the node's scroll position when it loads.
  172.       clone.addEventListener(
  173.         "load",
  174.         function() {
  175.           clone.scrollTop = node.scrollTop;
  176.           clone.scrollLeft = node.scrollLeft;
  177.         },
  178.         true
  179.       );
  180.     }
  182.     // Return the cloned node.
  183.     return clone;
  184.   };
  186.   /* ----- CONSTRUCTOR ----- */
  188.   var Worker = function Worker(opt) {
  189.     // Create the root parent for the proto chain, and the starting Worker.
  190.     var root = Object.assign(
  191.       Worker.convert(Promise.resolve()),
  192.       JSON.parse(JSON.stringify(Worker.template))
  193.     );
  194.     var self = Worker.convert(Promise.resolve(), root);
  196.     // Set progress, optional settings, and return.
  197.     self = self.setProgress(1, Worker, 1, [Worker]);
  198.     self = self.set(opt);
  199.     return self;
  200.   };
  202.   // Boilerplate for subclassing Promise.
  203.   Worker.prototype = Object.create(Promise.prototype);
  204.   Worker.prototype.constructor = Worker;
  206.   // Converts/casts promises into Workers.
  207.   Worker.convert = function convert(promise, inherit) {
  208.     // Uses prototypal inheritance to receive changes made to ancestors' properties.
  209.     promise.__proto__ = inherit || Worker.prototype;
  210.     return promise;
  211.   };
  213.   Worker.template = {
  214.     prop: {
  215.       src: null,
  216.       container: null,
  217.       overlay: null,
  218.       canvas: null,
  219.       img: null,
  220.       pdf: null,
  221.       pageSize: null,
  222.       callback: function() {}
  223.     },
  224.     progress: {
  225.       val: 0,
  226.       state: null,
  227.       n: 0,
  228.       stack: []
  229.     },
  230.     opt: {
  231.       filename: "file.pdf",
  232.       margin: [0, 0, 0, 0],
  233.       enableLinks: true,
  234.       x: 0,
  235.       y: 0,
  236.       html2canvas: {},
  237.       jsPDF: {},
  238.       backgroundColor: "transparent"
  239.     }
  240.   };
  242.   /* ----- FROM / TO ----- */
  244.   Worker.prototype.from = function from(src, type) {
  245.     function getType(src) {
  246.       switch (objType(src)) {
  247.         case "string":
  248.           return "string";
  249.         case "element":
  250.           return src.nodeName.toLowerCase() === "canvas" ? "canvas" : "element";
  251.         default:
  252.           return "unknown";
  253.       }
  254.     }
  256.     return this.then(function from_main() {
  257.       type = type || getType(src);
  258.       switch (type) {
  259.         case "string":
  260.           return this.then(loadDomPurify).then(function(dompurify) {
  261.             return this.set({
  262.               src: createElement("div", {
  263.                 innerHTML: src,
  264.                 dompurify: dompurify
  265.               })
  266.             });
  267.           });
  268.         case "element":
  269.           return this.set({ src: src });
  270.         case "canvas":
  271.           return this.set({ canvas: src });
  272.         case "img":
  273.           return this.set({ img: src });
  274.         default:
  275.           return this.error("Unknown source type.");
  276.       }
  277.     });
  278.   };
  280.   Worker.prototype.to = function to(target) {
  281.     // Route the 'to' request to the appropriate method.
  282.     switch (target) {
  283.       case "container":
  284.         return this.toContainer();
  285.       case "canvas":
  286.         return this.toCanvas();
  287.       case "img":
  288.         return this.toImg();
  289.       case "pdf":
  290.         return this.toPdf();
  291.       default:
  292.         return this.error("Invalid target.");
  293.     }
  294.   };
  296.   Worker.prototype.toContainer = function toContainer() {
  297.     // Set up function prerequisites.
  298.     var prereqs = [
  299.       function checkSrc() {
  300.         return (
  301.           this.prop.src || this.error("Cannot duplicate - no source HTML.")
  302.         );
  303.       },
  304.       function checkPageSize() {
  305.         return this.prop.pageSize || this.setPageSize();
  306.       }
  307.     ];
  308.     return this.thenList(prereqs).then(function toContainer_main() {
  309.       // Define the CSS styles for the container and its overlay parent.
  310.       var overlayCSS = {
  311.         position: "fixed",
  312.         overflow: "hidden",
  313.         zIndex: 1000,
  314.         left: "-100000px",
  315.         right: 0,
  316.         bottom: 0,
  317.         top: 0
  318.       };
  319.       var containerCSS = {
  320.         position: "relative",
  321.         display: "inline-block",
  322.         width:
  323.           (typeof this.opt.width === "number" &&
  324.           !isNaN(this.opt.width) &&
  325.           typeof this.opt.windowWidth === "number" &&
  326.           !isNaN(this.opt.windowWidth)
  327.             ? this.opt.windowWidth
  328.             : Math.max(
  329.                 this.prop.src.clientWidth,
  330.                 this.prop.src.scrollWidth,
  331.                 this.prop.src.offsetWidth
  332.               )) + "px",
  333.         left: 0,
  334.         right: 0,
  335.         top: 0,
  336.         margin: "auto",
  337.         backgroundColor: this.opt.backgroundColor
  338.       }; // Set the overlay to hidden (could be changed in the future to provide a print preview).
  340.       var source = cloneNode(
  341.         this.prop.src,
  342.         this.opt.html2canvas.javascriptEnabled
  343.       );
  345.       if (source.tagName === "BODY") {
  346.         containerCSS.height =
  347.           Math.max(
  348.             document.body.scrollHeight,
  349.             document.body.offsetHeight,
  350.             document.documentElement.clientHeight,
  351.             document.documentElement.scrollHeight,
  352.             document.documentElement.offsetHeight
  353.           ) + "px";
  354.       }
  356.       this.prop.overlay = createElement("div", {
  357.         className: "html2pdf__overlay",
  358.         style: overlayCSS
  359.       });
  360.       this.prop.container = createElement("div", {
  361.         className: "html2pdf__container",
  362.         style: containerCSS
  363.       });
  364.       this.prop.container.appendChild(source);
  365.       this.prop.container.firstChild.appendChild(
  366.         createElement("div", {
  367.           style: {
  368.             clear: "both",
  369.             border: "0 none transparent",
  370.             margin: 0,
  371.             padding: 0,
  372.             height: 0
  373.           }
  374.         })
  375.       );
  376.       this.prop.container.style.float = "none";
  377.       this.prop.overlay.appendChild(this.prop.container);
  378.       document.body.appendChild(this.prop.overlay);
  379.       this.prop.container.firstChild.style.position = "relative";
  380.       this.prop.container.height =
  381.         Math.max(
  382.           this.prop.container.firstChild.clientHeight,
  383.           this.prop.container.firstChild.scrollHeight,
  384.           this.prop.container.firstChild.offsetHeight
  385.         ) + "px";
  386.     });
  387.   };
  389.   Worker.prototype.toCanvas = function toCanvas() {
  390.     // Set up function prerequisites.
  391.     var prereqs = [
  392.       function checkContainer() {
  393.         return (
  394.           document.body.contains(this.prop.container) || this.toContainer()
  395.         );
  396.       }
  397.     ];
  399.     // Fulfill prereqs then create the canvas.
  400.     return this.thenList(prereqs)
  401.       .then(loadHtml2Canvas)
  402.       .then(function toCanvas_main(html2canvas) {
  403.         // Handle old-fashioned 'onrendered' argument.
  404.         var options = Object.assign({}, this.opt.html2canvas);
  405.         delete options.onrendered;
  407.         return html2canvas(this.prop.container, options);
  408.       })
  409.       .then(function toCanvas_post(canvas) {
  410.         // Handle old-fashioned 'onrendered' argument.
  411.         var onRendered = this.opt.html2canvas.onrendered || function() {};
  412.         onRendered(canvas);
  414.         this.prop.canvas = canvas;
  415.         document.body.removeChild(this.prop.overlay);
  416.       });
  417.   };
  419.   Worker.prototype.toContext2d = function toContext2d() {
  420.     // Set up function prerequisites.
  421.     var prereqs = [
  422.       function checkContainer() {
  423.         return (
  424.           document.body.contains(this.prop.container) || this.toContainer()
  425.         );
  426.       }
  427.     ];
  429.     // Fulfill prereqs then create the canvas.
  430.     return this.thenList(prereqs)
  431.       .then(loadHtml2Canvas)
  432.       .then(function toContext2d_main(html2canvas) {
  433.         // Handle old-fashioned 'onrendered' argument.
  435.         var pdf = this.opt.jsPDF;
  436.         var fontFaces = this.opt.fontFaces;
  438.         var scale =
  439.           typeof this.opt.width === "number" &&
  440.           !isNaN(this.opt.width) &&
  441.           typeof this.opt.windowWidth === "number" &&
  442.           !isNaN(this.opt.windowWidth)
  443.             ? this.opt.width / this.opt.windowWidth
  444.             : 1;
  446.         var options = Object.assign(
  447.           {
  448.             async: true,
  449.             allowTaint: true,
  450.             scale: scale,
  451.             scrollX: this.opt.scrollX || 0,
  452.             scrollY: this.opt.scrollY || 0,
  453.             backgroundColor: "#ffffff",
  454.             imageTimeout: 15000,
  455.             logging: true,
  456.             proxy: null,
  457.             removeContainer: true,
  458.             foreignObjectRendering: false,
  459.             useCORS: false
  460.           },
  461.           this.opt.html2canvas
  462.         );
  463.         delete options.onrendered;
  465.         pdf.context2d.autoPaging =
  466.           typeof this.opt.autoPaging === "undefined"
  467.             ? true
  468.             : this.opt.autoPaging;
  469.         pdf.context2d.posX = this.opt.x;
  470.         pdf.context2d.posY = this.opt.y;
  471.         pdf.context2d.margin = this.opt.margin;
  472.         pdf.context2d.fontFaces = fontFaces;
  474.         if (fontFaces) {
  475.           for (var i = 0; i < fontFaces.length; ++i) {
  476.             var font = fontFaces[i];
  477.             var src = font.src.find(function(src) {
  478.               return src.format === "truetype";
  479.             });
  481.             if (src) {
  482.               pdf.addFont(src.url, font.ref.name, font.ref.style);
  483.             }
  484.           }
  485.         }
  487.         options.windowHeight = options.windowHeight || 0;
  488.         options.windowHeight =
  489.           options.windowHeight == 0
  490.             ? Math.max(
  491.                 this.prop.container.clientHeight,
  492.                 this.prop.container.scrollHeight,
  493.                 this.prop.container.offsetHeight
  494.               )
  495.             : options.windowHeight;
  497.         pdf.context2d.save(true);
  498.         return html2canvas(this.prop.container, options);
  499.       })
  500.       .then(function toContext2d_post(canvas) {
  501.         this.opt.jsPDF.context2d.restore(true);
  503.         // Handle old-fashioned 'onrendered' argument.
  504.         var onRendered = this.opt.html2canvas.onrendered || function() {};
  505.         onRendered(canvas);
  507.         this.prop.canvas = canvas;
  508.         document.body.removeChild(this.prop.overlay);
  509.       });
  510.   };
  512.   Worker.prototype.toImg = function toImg() {
  513.     // Set up function prerequisites.
  514.     var prereqs = [
  515.       function checkCanvas() {
  516.         return this.prop.canvas || this.toCanvas();
  517.       }
  518.     ];
  520.     // Fulfill prereqs then create the image.
  521.     return this.thenList(prereqs).then(function toImg_main() {
  522.       var imgData = this.prop.canvas.toDataURL(
  523.         "image/" + this.opt.image.type,
  524.         this.opt.image.quality
  525.       );
  526.       this.prop.img = document.createElement("img");
  527.       this.prop.img.src = imgData;
  528.     });
  529.   };
  531.   Worker.prototype.toPdf = function toPdf() {
  532.     // Set up function prerequisites.
  533.     var prereqs = [
  534.       function checkContext2d() {
  535.         return this.toContext2d();
  536.       }
  537.       //function checkCanvas() { return this.prop.canvas || this.toCanvas(); }
  538.     ];
  540.     // Fulfill prereqs then create the image.
  541.     return this.thenList(prereqs).then(function toPdf_main() {
  542.       // Create local copies of frequently used properties.
  543.       this.prop.pdf = this.prop.pdf || this.opt.jsPDF;
  544.     });
  545.   };
  547.   /* ----- OUTPUT / SAVE ----- */
  549.   Worker.prototype.output = function output(type, options, src) {
  550.     // Redirect requests to the correct function (outputPdf / outputImg).
  551.     src = src || "pdf";
  552.     if (src.toLowerCase() === "img" || src.toLowerCase() === "image") {
  553.       return this.outputImg(type, options);
  554.     } else {
  555.       return this.outputPdf(type, options);
  556.     }
  557.   };
  559.   Worker.prototype.outputPdf = function outputPdf(type, options) {
  560.     // Set up function prerequisites.
  561.     var prereqs = [
  562.       function checkPdf() {
  563.         return this.prop.pdf || this.toPdf();
  564.       }
  565.     ];
  567.     // Fulfill prereqs then perform the appropriate output.
  568.     return this.thenList(prereqs).then(function outputPdf_main() {
  569.       /* Currently implemented output types:
  570.        *    https://rawgit.com/MrRio/jsPDF/master/docs/jspdf.js.html#line992
  571.        *  save(options), arraybuffer, blob, bloburi/bloburl,
  572.        *  datauristring/dataurlstring, dataurlnewwindow, datauri/dataurl
  573.        */
  574.       return this.prop.pdf.output(type, options);
  575.     });
  576.   };
  578.   Worker.prototype.outputImg = function outputImg(type) {
  579.     // Set up function prerequisites.
  580.     var prereqs = [
  581.       function checkImg() {
  582.         return this.prop.img || this.toImg();
  583.       }
  584.     ];
  586.     // Fulfill prereqs then perform the appropriate output.
  587.     return this.thenList(prereqs).then(function outputImg_main() {
  588.       switch (type) {
  589.         case undefined:
  590.         case "img":
  591.           return this.prop.img;
  592.         case "datauristring":
  593.         case "dataurlstring":
  594.           return this.prop.img.src;
  595.         case "datauri":
  596.         case "dataurl":
  597.           return (document.location.href = this.prop.img.src);
  598.         default:
  599.           throw 'Image output type "' + type + '" is not supported.';
  600.       }
  601.     });
  602.   };
  604.   Worker.prototype.save = function save(filename) {
  605.     // Set up function prerequisites.
  606.     var prereqs = [
  607.       function checkPdf() {
  608.         return this.prop.pdf || this.toPdf();
  609.       }
  610.     ];
  612.     // Fulfill prereqs, update the filename (if provided), and save the PDF.
  613.     return this.thenList(prereqs)
  614.       .set(filename ? { filename: filename } : null)
  615.       .then(function save_main() {
  616.         this.prop.pdf.save(this.opt.filename);
  617.       });
  618.   };
  620.   Worker.prototype.doCallback = function doCallback() {
  621.     // Set up function prerequisites.
  622.     var prereqs = [
  623.       function checkPdf() {
  624.         return this.prop.pdf || this.toPdf();
  625.       }
  626.     ];
  628.     // Fulfill prereqs, update the filename (if provided), and save the PDF.
  629.     return this.thenList(prereqs).then(function doCallback_main() {
  630.       this.prop.callback(this.prop.pdf);
  631.     });
  632.   };
  634.   /* ----- SET / GET ----- */
  636.   Worker.prototype.set = function set(opt) {
  637.     // TODO: Implement ordered pairs?
  639.     // Silently ignore invalid or empty input.
  640.     if (objType(opt) !== "object") {
  641.       return this;
  642.     }
  644.     // Build an array of setter functions to queue.
  645.     var fns = Object.keys(opt || {}).map(function(key) {
  646.       if (key in Worker.template.prop) {
  647.         // Set pre-defined properties.
  648.         return function set_prop() {
  649.           this.prop[key] = opt[key];
  650.         };
  651.       } else {
  652.         switch (key) {
  653.           case "margin":
  654.             return this.setMargin.bind(this, opt.margin);
  655.           case "jsPDF":
  656.             return function set_jsPDF() {
  657.               this.opt.jsPDF = opt.jsPDF;
  658.               return this.setPageSize();
  659.             };
  660.           case "pageSize":
  661.             return this.setPageSize.bind(this, opt.pageSize);
  662.           default:
  663.             // Set any other properties in opt.
  664.             return function set_opt() {
  665.               this.opt[key] = opt[key];
  666.             };
  667.         }
  668.       }
  669.     }, this);
  671.     // Set properties within the promise chain.
  672.     return this.then(function set_main() {
  673.       return this.thenList(fns);
  674.     });
  675.   };
  677.   Worker.prototype.get = function get(key, cbk) {
  678.     return this.then(function get_main() {
  679.       // Fetch the requested property, either as a predefined prop or in opt.
  680.       var val = key in Worker.template.prop ? this.prop[key] : this.opt[key];
  681.       return cbk ? cbk(val) : val;
  682.     });
  683.   };
  685.   Worker.prototype.setMargin = function setMargin(margin) {
  686.     return this.then(function setMargin_main() {
  687.       // Parse the margin property.
  688.       switch (objType(margin)) {
  689.         case "number":
  690.           margin = [margin, margin, margin, margin];
  691.         // eslint-disable-next-line no-fallthrough
  692.         case "array":
  693.           if (margin.length === 2) {
  694.             margin = [margin[0], margin[1], margin[0], margin[1]];
  695.           }
  696.           if (margin.length === 4) {
  697.             break;
  698.           }
  699.         // eslint-disable-next-line no-fallthrough
  700.         default:
  701.           return this.error("Invalid margin array.");
  702.       }
  704.       // Set the margin property, then update pageSize.
  705.       this.opt.margin = margin;
  706.     }).then(this.setPageSize);
  707.   };
  709.   Worker.prototype.setPageSize = function setPageSize(pageSize) {
  710.     function toPx(val, k) {
  711.       return Math.floor(((val * k) / 72) * 96);
  712.     }
  714.     return this.then(function setPageSize_main() {
  715.       // Retrieve page-size based on jsPDF settings, if not explicitly provided.
  716.       pageSize = pageSize || jsPDF.getPageSize(this.opt.jsPDF);
  718.       // Add 'inner' field if not present.
  719.       if (!pageSize.hasOwnProperty("inner")) {
  720.         pageSize.inner = {
  721.           width: pageSize.width - this.opt.margin[1] - this.opt.margin[3],
  722.           height: pageSize.height - this.opt.margin[0] - this.opt.margin[2]
  723.         };
  724.         pageSize.inner.px = {
  725.           width: toPx(pageSize.inner.width, pageSize.k),
  726.           height: toPx(pageSize.inner.height, pageSize.k)
  727.         };
  728.         pageSize.inner.ratio = pageSize.inner.height / pageSize.inner.width;
  729.       }
  731.       // Attach pageSize to this.
  732.       this.prop.pageSize = pageSize;
  733.     });
  734.   };
  736.   Worker.prototype.setProgress = function setProgress(val, state, n, stack) {
  737.     // Immediately update all progress values.
  738.     if (val != null) this.progress.val = val;
  739.     if (state != null) this.progress.state = state;
  740.     if (n != null) this.progress.n = n;
  741.     if (stack != null) this.progress.stack = stack;
  742.     this.progress.ratio = this.progress.val / this.progress.state;
  744.     // Return this for command chaining.
  745.     return this;
  746.   };
  748.   Worker.prototype.updateProgress = function updateProgress(
  749.     val,
  750.     state,
  751.     n,
  752.     stack
  753.   ) {
  754.     // Immediately update all progress values, using setProgress.
  755.     return this.setProgress(
  756.       val ? this.progress.val + val : null,
  757.       state ? state : null,
  758.       n ? this.progress.n + n : null,
  759.       stack ? this.progress.stack.concat(stack) : null
  760.     );
  761.   };
  763.   /* ----- PROMISE MAPPING ----- */
  765.   Worker.prototype.then = function then(onFulfilled, onRejected) {
  766.     // Wrap `this` for encapsulation.
  767.     var self = this;
  769.     return this.thenCore(onFulfilled, onRejected, function then_main(
  770.       onFulfilled,
  771.       onRejected
  772.     ) {
  773.       // Update progress while queuing, calling, and resolving `then`.
  774.       self.updateProgress(null, null, 1, [onFulfilled]);
  775.       return Promise.prototype.then
  776.         .call(this, function then_pre(val) {
  777.           self.updateProgress(null, onFulfilled);
  778.           return val;
  779.         })
  780.         .then(onFulfilled, onRejected)
  781.         .then(function then_post(val) {
  782.           self.updateProgress(1);
  783.           return val;
  784.         });
  785.     });
  786.   };
  788.   Worker.prototype.thenCore = function thenCore(
  789.     onFulfilled,
  790.     onRejected,
  791.     thenBase
  792.   ) {
  793.     // Handle optional thenBase parameter.
  794.     thenBase = thenBase || Promise.prototype.then;
  796.     // Wrap `this` for encapsulation and bind it to the promise handlers.
  797.     var self = this;
  798.     if (onFulfilled) {
  799.       onFulfilled = onFulfilled.bind(self);
  800.     }
  801.     if (onRejected) {
  802.       onRejected = onRejected.bind(self);
  803.     }
  805.     // Cast self into a Promise to avoid polyfills recursively defining `then`.
  806.     var isNative =
  807.       Promise.toString().indexOf("[native code]") !== -1 &&
  808.       Promise.name === "Promise";
  809.     var selfPromise = isNative
  810.       ? self
  811.       : Worker.convert(Object.assign({}, self), Promise.prototype);
  813.     // Return the promise, after casting it into a Worker and preserving props.
  814.     var returnVal = thenBase.call(selfPromise, onFulfilled, onRejected);
  815.     return Worker.convert(returnVal, self.__proto__);
  816.   };
  818.   Worker.prototype.thenExternal = function thenExternal(
  819.     onFulfilled,
  820.     onRejected
  821.   ) {
  822.     // Call `then` and return a standard promise (exits the Worker chain).
  823.     return Promise.prototype.then.call(this, onFulfilled, onRejected);
  824.   };
  826.   Worker.prototype.thenList = function thenList(fns) {
  827.     // Queue a series of promise 'factories' into the promise chain.
  828.     var self = this;
  829.     fns.forEach(function thenList_forEach(fn) {
  830.       self = self.thenCore(fn);
  831.     });
  832.     return self;
  833.   };
  835.   Worker.prototype["catch"] = function(onRejected) {
  836.     // Bind `this` to the promise handler, call `catch`, and return a Worker.
  837.     if (onRejected) {
  838.       onRejected = onRejected.bind(this);
  839.     }
  840.     var returnVal = Promise.prototype["catch"].call(this, onRejected);
  841.     return Worker.convert(returnVal, this);
  842.   };
  844.   Worker.prototype.catchExternal = function catchExternal(onRejected) {
  845.     // Call `catch` and return a standard promise (exits the Worker chain).
  846.     return Promise.prototype["catch"].call(this, onRejected);
  847.   };
  849.   Worker.prototype.error = function error(msg) {
  850.     // Throw the error in the Promise chain.
  851.     return this.then(function error_main() {
  852.       throw new Error(msg);
  853.     });
  854.   };
  856.   /* ----- ALIASES ----- */
  858.   Worker.prototype.using = Worker.prototype.set;
  859.   Worker.prototype.saveAs = Worker.prototype.save;
  860.   Worker.prototype.export = Worker.prototype.output;
  861.   Worker.prototype.run = Worker.prototype.then;
  863.   // Get dimensions of a PDF page, as determined by jsPDF.
  864.   jsPDF.getPageSize = function(orientation, unit, format) {
  865.     // Decode options object
  866.     if (typeof orientation === "object") {
  867.       var options = orientation;
  868.       orientation = options.orientation;
  869.       unit = options.unit || unit;
  870.       format = options.format || format;
  871.     }
  873.     // Default options
  874.     unit = unit || "mm";
  875.     format = format || "a4";
  876.     orientation = ("" + (orientation || "P")).toLowerCase();
  877.     var format_as_string = ("" + format).toLowerCase();
  879.     // Size in pt of various paper formats
  880.     var pageFormats = {
  881.       a0: [2383.94, 3370.39],
  882.       a1: [1683.78, 2383.94],
  883.       a2: [1190.55, 1683.78],
  884.       a3: [841.89, 1190.55],
  885.       a4: [595.28, 841.89],
  886.       a5: [419.53, 595.28],
  887.       a6: [297.64, 419.53],
  888.       a7: [209.76, 297.64],
  889.       a8: [147.4, 209.76],
  890.       a9: [104.88, 147.4],
  891.       a10: [73.7, 104.88],
  892.       b0: [2834.65, 4008.19],
  893.       b1: [2004.09, 2834.65],
  894.       b2: [1417.32, 2004.09],
  895.       b3: [1000.63, 1417.32],
  896.       b4: [708.66, 1000.63],
  897.       b5: [498.9, 708.66],
  898.       b6: [354.33, 498.9],
  899.       b7: [249.45, 354.33],
  900.       b8: [175.75, 249.45],
  901.       b9: [124.72, 175.75],
  902.       b10: [87.87, 124.72],
  903.       c0: [2599.37, 3676.54],
  904.       c1: [1836.85, 2599.37],
  905.       c2: [1298.27, 1836.85],
  906.       c3: [918.43, 1298.27],
  907.       c4: [649.13, 918.43],
  908.       c5: [459.21, 649.13],
  909.       c6: [323.15, 459.21],
  910.       c7: [229.61, 323.15],
  911.       c8: [161.57, 229.61],
  912.       c9: [113.39, 161.57],
  913.       c10: [79.37, 113.39],
  914.       dl: [311.81, 623.62],
  915.       letter: [612, 792],
  916.       "government-letter": [576, 756],
  917.       legal: [612, 1008],
  918.       "junior-legal": [576, 360],
  919.       ledger: [1224, 792],
  920.       tabloid: [792, 1224],
  921.       "credit-card": [153, 243]
  922.     };
  924.     var k;
  925.     // Unit conversion
  926.     switch (unit) {
  927.       case "pt":
  928.         k = 1;
  929.         break;
  930.       case "mm":
  931.         k = 72 / 25.4;
  932.         break;
  933.       case "cm":
  934.         k = 72 / 2.54;
  935.         break;
  936.       case "in":
  937.         k = 72;
  938.         break;
  939.       case "px":
  940.         k = 72 / 96;
  941.         break;
  942.       case "pc":
  943.         k = 12;
  944.         break;
  945.       case "em":
  946.         k = 12;
  947.         break;
  948.       case "ex":
  949.         k = 6;
  950.         break;
  951.       default:
  952.         throw "Invalid unit: " + unit;
  953.     }
  954.     var pageHeight = 0;
  955.     var pageWidth = 0;
  957.     // Dimensions are stored as user units and converted to points on output
  958.     if (pageFormats.hasOwnProperty(format_as_string)) {
  959.       pageHeight = pageFormats[format_as_string][1] / k;
  960.       pageWidth = pageFormats[format_as_string][0] / k;
  961.     } else {
  962.       try {
  963.         pageHeight = format[1];
  964.         pageWidth = format[0];
  965.       } catch (err) {
  966.         throw new Error("Invalid format: " + format);
  967.       }
  968.     }
  970.     var tmp;
  971.     // Handle page orientation
  972.     if (orientation === "p" || orientation === "portrait") {
  973.       orientation = "p";
  974.       if (pageWidth > pageHeight) {
  975.         tmp = pageWidth;
  976.         pageWidth = pageHeight;
  977.         pageHeight = tmp;
  978.       }
  979.     } else if (orientation === "l" || orientation === "landscape") {
  980.       orientation = "l";
  981.       if (pageHeight > pageWidth) {
  982.         tmp = pageWidth;
  983.         pageWidth = pageHeight;
  984.         pageHeight = tmp;
  985.       }
  986.     } else {
  987.       throw "Invalid orientation: " + orientation;
  988.     }
  990.     // Return information (k is the unit conversion ratio from pts)
  991.     var info = {
  992.       width: pageWidth,
  993.       height: pageHeight,
  994.       unit: unit,
  995.       k: k,
  996.       orientation: orientation
  997.     };
  998.     return info;
  999.   };
  1001.   /**
  1002.    * @typedef FontFace
  1003.    *
  1004.    * The font-face type implements an interface similar to that of the font-face CSS rule,
  1005.    * and is used by jsPDF to match fonts when the font property of CanvasRenderingContext2D
  1006.    * is updated.
  1007.    *
  1008.    * All properties expect values similar to those in the font-face CSS rule. A difference
  1009.    * is the font-family, which do not need to be enclosed in double-quotes when containing
  1010.    * spaces like in CSS.
  1011.    *
  1012.    * @property {string} family The name of the font-family.
  1013.    * @property {string|undefined} style The style that this font-face defines, e.g. 'italic'.
  1014.    * @property {string|number|undefined} weight The weight of the font, either as a string or a number (400, 500, 600, e.g.)
  1015.    * @property {string|undefined} stretch The stretch of the font, e.g. condensed, normal, expanded.
  1016.    * @property {Object[]} src A list of URLs from where fonts of various formats can be fetched.
  1017.    * @property {string} [src] url A URL to a font of a specific format.
  1018.    * @property {string} [src] format Format of the font referenced by the URL.
  1019.    */
  1021.   /**
  1022.    * Generate a PDF from an HTML element or string using.
  1023.    *
  1024.    * @name html
  1025.    * @function
  1026.    * @param {HTMLElement|string} source The source HTMLElement or a string containing HTML.
  1027.    * @param {Object} [options] Collection of settings
  1028.    * @param {function} [options.callback] The mandatory callback-function gets as first parameter the current jsPDF instance
  1029.    * @param {(number|number[])=} [options.margin] Page margins [top, right, bottom, left]. Default is 0.
  1030.    * @param {(boolean|'slice'|'text')=} [options.autoPaging] The auto paging mode.
  1031.    * <ul>
  1032.    * <li>
  1033.    *   <code>false</code>: Auto paging is disabled.
  1034.    * </li>
  1035.    * <li>
  1036.    *   <code>true</code> or <code>'slice'</code>: Will cut shapes or text chunks across page breaks. Will possibly
  1037.    *   slice text in half, making it difficult to read.
  1038.    * </li>
  1039.    * <li>
  1040.    *   <code>'text'</code>: Trys not to cut text in half across page breaks. Works best for documents consisting
  1041.    *   mostly of a single column of text.
  1042.    * </li>
  1043.    * </ul>
  1044.    * Default is <code>true</code>.
  1045.    * @param {string} [options.filename] name of the file
  1046.    * @param {HTMLOptionImage} [options.image] image settings when converting HTML to image
  1047.    * @param {Html2CanvasOptions} [options.html2canvas] html2canvas options
  1048.    * @param {FontFace[]} [options.fontFaces] A list of font-faces to match when resolving fonts. Fonts will be added to the PDF based on the specified URL. If omitted, the font match algorithm falls back to old algorithm.
  1049.    * @param {jsPDF} [options.jsPDF] jsPDF instance
  1050.    * @param {number=} [options.x] x position on the PDF document in jsPDF units.
  1051.    * @param {number=} [options.y] y position on the PDF document in jsPDF units.
  1052.    * @param {number=} [options.width] The target width in the PDF document in jsPDF units. The rendered element will be
  1053.    * scaled such that it fits into the specified width. Has no effect if either the <code>html2canvas.scale<code> is
  1054.    * specified or the <code>windowWidth</code> option is NOT specified.
  1055.    * @param {number=} [options.windowWidth] The window width in CSS pixels. In contrast to the
  1056.    * <code>html2canvas.windowWidth</code> option, this option affects the actual container size while rendering and
  1057.    * does NOT affect CSS media queries. This option only has an effect, if the <code>width<code> option is also specified.
  1058.    *
  1059.    * @example
  1060.    * var doc = new jsPDF();
  1061.    *
  1062.    * doc.html(document.body, {
  1063.    *    callback: function (doc) {
  1064.    *      doc.save();
  1065.    *    },
  1066.    *    x: 10,
  1067.    *    y: 10
  1068.    * });
  1069.    */
  1070.   jsPDFAPI.html = function(src, options) {
  1071.     "use strict";
  1073.     options = options || {};
  1074.     options.callback = options.callback || function() {};
  1075.     options.html2canvas = options.html2canvas || {};
  1076.     options.html2canvas.canvas = options.html2canvas.canvas || this.canvas;
  1077.     options.jsPDF = options.jsPDF || this;
  1078.     options.fontFaces = options.fontFaces
  1079.       ? options.fontFaces.map(normalizeFontFace)
  1080.       : null;
  1082.     // Create a new worker with the given options.
  1083.     var worker = new Worker(options);
  1085.     if (!options.worker) {
  1086.       // If worker is not set to true, perform the traditional 'simple' operation.
  1087.       return worker.from(src).doCallback();
  1088.     } else {
  1089.       // Otherwise, return the worker for new Promise-based operation.
  1090.       return worker;
  1091.     }
  1092.   };
  1093. })(jsPDF.API);