modules/context2d.js

  1. /* eslint-disable no-fallthrough */
  2. /* eslint-disable no-console */
  3. /**
  4.  * @license
  5.  * jsPDF Context2D PlugIn Copyright (c) 2014 Steven Spungin (TwelveTone LLC) steven@twelvetone.tv
  6.  *
  7.  * Licensed under the MIT License. http://opensource.org/licenses/mit-license
  8.  */
  10. import { jsPDF } from "../jspdf.js";
  11. import { RGBColor } from "../libs/rgbcolor.js";
  12. import { console } from "../libs/console.js";
  13. import {
  14.   buildFontFaceMap,
  15.   parseFontFamily,
  16.   resolveFontFace
  17. } from "../libs/fontFace.js";
  19. /**
  20.  * This plugin mimics the HTML5 CanvasRenderingContext2D.
  21.  *
  22.  * The goal is to provide a way for current canvas implementations to print directly to a PDF.
  23.  *
  24.  * @name context2d
  25.  * @module
  26.  */
  27. (function(jsPDFAPI) {
  28.   "use strict";
  29.   var ContextLayer = function(ctx) {
  30.     ctx = ctx || {};
  31.     this.isStrokeTransparent = ctx.isStrokeTransparent || false;
  32.     this.strokeOpacity = ctx.strokeOpacity || 1;
  33.     this.strokeStyle = ctx.strokeStyle || "#000000";
  34.     this.fillStyle = ctx.fillStyle || "#000000";
  35.     this.isFillTransparent = ctx.isFillTransparent || false;
  36.     this.fillOpacity = ctx.fillOpacity || 1;
  37.     this.font = ctx.font || "10px sans-serif";
  38.     this.textBaseline = ctx.textBaseline || "alphabetic";
  39.     this.textAlign = ctx.textAlign || "left";
  40.     this.lineWidth = ctx.lineWidth || 1;
  41.     this.lineJoin = ctx.lineJoin || "miter";
  42.     this.lineCap = ctx.lineCap || "butt";
  43.     this.path = ctx.path || [];
  44.     this.transform =
  45.       typeof ctx.transform !== "undefined"
  46.         ? ctx.transform.clone()
  47.         : new Matrix();
  48.     this.globalCompositeOperation = ctx.globalCompositeOperation || "normal";
  49.     this.globalAlpha = ctx.globalAlpha || 1.0;
  50.     this.clip_path = ctx.clip_path || [];
  51.     this.currentPoint = ctx.currentPoint || new Point();
  52.     this.miterLimit = ctx.miterLimit || 10.0;
  53.     this.lastPoint = ctx.lastPoint || new Point();
  54.     this.lineDashOffset = ctx.lineDashOffset || 0.0;
  55.     this.lineDash = ctx.lineDash || [];
  56.     this.margin = ctx.margin || [0, 0, 0, 0];
  57.     this.prevPageLastElemOffset = ctx.prevPageLastElemOffset || 0;
  59.     this.ignoreClearRect =
  60.       typeof ctx.ignoreClearRect === "boolean" ? ctx.ignoreClearRect : true;
  61.     return this;
  62.   };
  64.   //stub
  65.   var f2,
  66.     getHorizontalCoordinateString,
  67.     getVerticalCoordinateString,
  68.     getHorizontalCoordinate,
  69.     getVerticalCoordinate,
  70.     Point,
  71.     Rectangle,
  72.     Matrix,
  73.     _ctx;
  74.   jsPDFAPI.events.push([
  75.     "initialized",
  76.     function() {
  77.       this.context2d = new Context2D(this);
  79.       f2 = this.internal.f2;
  80.       getHorizontalCoordinateString = this.internal.getCoordinateString;
  81.       getVerticalCoordinateString = this.internal.getVerticalCoordinateString;
  82.       getHorizontalCoordinate = this.internal.getHorizontalCoordinate;
  83.       getVerticalCoordinate = this.internal.getVerticalCoordinate;
  84.       Point = this.internal.Point;
  85.       Rectangle = this.internal.Rectangle;
  86.       Matrix = this.internal.Matrix;
  87.       _ctx = new ContextLayer();
  88.     }
  89.   ]);
  91.   var Context2D = function(pdf) {
  92.     Object.defineProperty(this, "canvas", {
  93.       get: function() {
  94.         return { parentNode: false, style: false };
  95.       }
  96.     });
  98.     var _pdf = pdf;
  99.     Object.defineProperty(this, "pdf", {
  100.       get: function() {
  101.         return _pdf;
  102.       }
  103.     });
  105.     var _pageWrapXEnabled = false;
  106.     /**
  107.      * @name pageWrapXEnabled
  108.      * @type {boolean}
  109.      * @default false
  110.      */
  111.     Object.defineProperty(this, "pageWrapXEnabled", {
  112.       get: function() {
  113.         return _pageWrapXEnabled;
  114.       },
  115.       set: function(value) {
  116.         _pageWrapXEnabled = Boolean(value);
  117.       }
  118.     });
  120.     var _pageWrapYEnabled = false;
  121.     /**
  122.      * @name pageWrapYEnabled
  123.      * @type {boolean}
  124.      * @default true
  125.      */
  126.     Object.defineProperty(this, "pageWrapYEnabled", {
  127.       get: function() {
  128.         return _pageWrapYEnabled;
  129.       },
  130.       set: function(value) {
  131.         _pageWrapYEnabled = Boolean(value);
  132.       }
  133.     });
  135.     var _posX = 0;
  136.     /**
  137.      * @name posX
  138.      * @type {number}
  139.      * @default 0
  140.      */
  141.     Object.defineProperty(this, "posX", {
  142.       get: function() {
  143.         return _posX;
  144.       },
  145.       set: function(value) {
  146.         if (!isNaN(value)) {
  147.           _posX = value;
  148.         }
  149.       }
  150.     });
  152.     var _posY = 0;
  153.     /**
  154.      * @name posY
  155.      * @type {number}
  156.      * @default 0
  157.      */
  158.     Object.defineProperty(this, "posY", {
  159.       get: function() {
  160.         return _posY;
  161.       },
  162.       set: function(value) {
  163.         if (!isNaN(value)) {
  164.           _posY = value;
  165.         }
  166.       }
  167.     });
  169.     /**
  170.      * Gets or sets the page margin when using auto paging. Has no effect when {@link autoPaging} is off.
  171.      * @name margin
  172.      * @type {number|number[]}
  173.      * @default [0, 0, 0, 0]
  174.      */
  175.     Object.defineProperty(this, "margin", {
  176.       get: function() {
  177.         return _ctx.margin;
  178.       },
  179.       set: function(value) {
  180.         var margin;
  181.         if (typeof value === "number") {
  182.           margin = [value, value, value, value];
  183.         } else {
  184.           margin = new Array(4);
  185.           margin[0] = value[0];
  186.           margin[1] = value.length >= 2 ? value[1] : margin[0];
  187.           margin[2] = value.length >= 3 ? value[2] : margin[0];
  188.           margin[3] = value.length >= 4 ? value[3] : margin[1];
  189.         }
  190.         _ctx.margin = margin;
  191.       }
  192.     });
  194.     var _autoPaging = false;
  195.     /**
  196.      * Gets or sets the auto paging mode. When auto paging is enabled, the context2d will automatically draw on the
  197.      * next page if a shape or text chunk doesn't fit entirely on the current page. The context2d will create new
  198.      * pages if required.
  199.      *
  200.      * Context2d supports different modes:
  201.      * <ul>
  202.      * <li>
  203.      *   <code>false</code>: Auto paging is disabled.
  204.      * </li>
  205.      * <li>
  206.      *   <code>true</code> or <code>'slice'</code>: Will cut shapes or text chunks across page breaks. Will possibly
  207.      *   slice text in half, making it difficult to read.
  208.      * </li>
  209.      * <li>
  210.      *   <code>'text'</code>: Trys not to cut text in half across page breaks. Works best for documents consisting
  211.      *   mostly of a single column of text.
  212.      * </li>
  213.      * </ul>
  214.      * @name Context2D#autoPaging
  215.      * @type {boolean|"slice"|"text"}
  216.      * @default false
  217.      */
  218.     Object.defineProperty(this, "autoPaging", {
  219.       get: function() {
  220.         return _autoPaging;
  221.       },
  222.       set: function(value) {
  223.         _autoPaging = value;
  224.       }
  225.     });
  227.     var lastBreak = 0;
  228.     /**
  229.      * @name lastBreak
  230.      * @type {number}
  231.      * @default 0
  232.      */
  233.     Object.defineProperty(this, "lastBreak", {
  234.       get: function() {
  235.         return lastBreak;
  236.       },
  237.       set: function(value) {
  238.         lastBreak = value;
  239.       }
  240.     });
  242.     var pageBreaks = [];
  243.     /**
  244.      * Y Position of page breaks.
  245.      * @name pageBreaks
  246.      * @type {number}
  247.      * @default 0
  248.      */
  249.     Object.defineProperty(this, "pageBreaks", {
  250.       get: function() {
  251.         return pageBreaks;
  252.       },
  253.       set: function(value) {
  254.         pageBreaks = value;
  255.       }
  256.     });
  258.     /**
  259.      * @name ctx
  260.      * @type {object}
  261.      * @default {}
  262.      */
  263.     Object.defineProperty(this, "ctx", {
  264.       get: function() {
  265.         return _ctx;
  266.       },
  267.       set: function(value) {
  268.         if (value instanceof ContextLayer) {
  269.           _ctx = value;
  270.         }
  271.       }
  272.     });
  274.     /**
  275.      * @name path
  276.      * @type {array}
  277.      * @default []
  278.      */
  279.     Object.defineProperty(this, "path", {
  280.       get: function() {
  281.         return _ctx.path;
  282.       },
  283.       set: function(value) {
  284.         _ctx.path = value;
  285.       }
  286.     });
  288.     /**
  289.      * @name ctxStack
  290.      * @type {array}
  291.      * @default []
  292.      */
  293.     var _ctxStack = [];
  294.     Object.defineProperty(this, "ctxStack", {
  295.       get: function() {
  296.         return _ctxStack;
  297.       },
  298.       set: function(value) {
  299.         _ctxStack = value;
  300.       }
  301.     });
  303.     /**
  304.      * Sets or returns the color, gradient, or pattern used to fill the drawing
  305.      *
  306.      * @name fillStyle
  307.      * @default #000000
  308.      * @property {(color|gradient|pattern)} value The color of the drawing. Default value is #000000<br />
  309.      * A gradient object (linear or radial) used to fill the drawing (not supported by context2d)<br />
  310.      * A pattern object to use to fill the drawing (not supported by context2d)
  311.      */
  312.     Object.defineProperty(this, "fillStyle", {
  313.       get: function() {
  314.         return this.ctx.fillStyle;
  315.       },
  316.       set: function(value) {
  317.         var rgba;
  318.         rgba = getRGBA(value);
  320.         this.ctx.fillStyle = rgba.style;
  321.         this.ctx.isFillTransparent = rgba.a === 0;
  322.         this.ctx.fillOpacity = rgba.a;
  324.         this.pdf.setFillColor(rgba.r, rgba.g, rgba.b, { a: rgba.a });
  325.         this.pdf.setTextColor(rgba.r, rgba.g, rgba.b, { a: rgba.a });
  326.       }
  327.     });
  329.     /**
  330.      * Sets or returns the color, gradient, or pattern used for strokes
  331.      *
  332.      * @name strokeStyle
  333.      * @default #000000
  334.      * @property {color} color A CSS color value that indicates the stroke color of the drawing. Default value is #000000 (not supported by context2d)
  335.      * @property {gradient} gradient A gradient object (linear or radial) used to create a gradient stroke (not supported by context2d)
  336.      * @property {pattern} pattern A pattern object used to create a pattern stroke (not supported by context2d)
  337.      */
  338.     Object.defineProperty(this, "strokeStyle", {
  339.       get: function() {
  340.         return this.ctx.strokeStyle;
  341.       },
  342.       set: function(value) {
  343.         var rgba = getRGBA(value);
  345.         this.ctx.strokeStyle = rgba.style;
  346.         this.ctx.isStrokeTransparent = rgba.a === 0;
  347.         this.ctx.strokeOpacity = rgba.a;
  349.         if (rgba.a === 0) {
  350.           this.pdf.setDrawColor(255, 255, 255);
  351.         } else if (rgba.a === 1) {
  352.           this.pdf.setDrawColor(rgba.r, rgba.g, rgba.b);
  353.         } else {
  354.           this.pdf.setDrawColor(rgba.r, rgba.g, rgba.b);
  355.         }
  356.       }
  357.     });
  359.     /**
  360.      * Sets or returns the style of the end caps for a line
  361.      *
  362.      * @name lineCap
  363.      * @default butt
  364.      * @property {(butt|round|square)} lineCap butt A flat edge is added to each end of the line <br/>
  365.      * round A rounded end cap is added to each end of the line<br/>
  366.      * square A square end cap is added to each end of the line<br/>
  367.      */
  368.     Object.defineProperty(this, "lineCap", {
  369.       get: function() {
  370.         return this.ctx.lineCap;
  371.       },
  372.       set: function(value) {
  373.         if (["butt", "round", "square"].indexOf(value) !== -1) {
  374.           this.ctx.lineCap = value;
  375.           this.pdf.setLineCap(value);
  376.         }
  377.       }
  378.     });
  380.     /**
  381.      * Sets or returns the current line width
  382.      *
  383.      * @name lineWidth
  384.      * @default 1
  385.      * @property {number} lineWidth The current line width, in pixels
  386.      */
  387.     Object.defineProperty(this, "lineWidth", {
  388.       get: function() {
  389.         return this.ctx.lineWidth;
  390.       },
  391.       set: function(value) {
  392.         if (!isNaN(value)) {
  393.           this.ctx.lineWidth = value;
  394.           this.pdf.setLineWidth(value);
  395.         }
  396.       }
  397.     });
  399.     /**
  400.      * Sets or returns the type of corner created, when two lines meet
  401.      */
  402.     Object.defineProperty(this, "lineJoin", {
  403.       get: function() {
  404.         return this.ctx.lineJoin;
  405.       },
  406.       set: function(value) {
  407.         if (["bevel", "round", "miter"].indexOf(value) !== -1) {
  408.           this.ctx.lineJoin = value;
  409.           this.pdf.setLineJoin(value);
  410.         }
  411.       }
  412.     });
  414.     /**
  415.      * A number specifying the miter limit ratio in coordinate space units. Zero, negative, Infinity, and NaN values are ignored. The default value is 10.0.
  416.      *
  417.      * @name miterLimit
  418.      * @default 10
  419.      */
  420.     Object.defineProperty(this, "miterLimit", {
  421.       get: function() {
  422.         return this.ctx.miterLimit;
  423.       },
  424.       set: function(value) {
  425.         if (!isNaN(value)) {
  426.           this.ctx.miterLimit = value;
  427.           this.pdf.setMiterLimit(value);
  428.         }
  429.       }
  430.     });
  432.     Object.defineProperty(this, "textBaseline", {
  433.       get: function() {
  434.         return this.ctx.textBaseline;
  435.       },
  436.       set: function(value) {
  437.         this.ctx.textBaseline = value;
  438.       }
  439.     });
  441.     Object.defineProperty(this, "textAlign", {
  442.       get: function() {
  443.         return this.ctx.textAlign;
  444.       },
  445.       set: function(value) {
  446.         if (["right", "end", "center", "left", "start"].indexOf(value) !== -1) {
  447.           this.ctx.textAlign = value;
  448.         }
  449.       }
  450.     });
  452.     var _fontFaceMap = null;
  454.     function getFontFaceMap(pdf, fontFaces) {
  455.       if (_fontFaceMap === null) {
  456.         var fontMap = pdf.getFontList();
  458.         var convertedFontFaces = convertToFontFaces(fontMap);
  460.         _fontFaceMap = buildFontFaceMap(convertedFontFaces.concat(fontFaces));
  461.       }
  463.       return _fontFaceMap;
  464.     }
  466.     function convertToFontFaces(fontMap) {
  467.       var fontFaces = [];
  469.       Object.keys(fontMap).forEach(function(family) {
  470.         var styles = fontMap[family];
  472.         styles.forEach(function(style) {
  473.           var fontFace = null;
  475.           switch (style) {
  476.             case "bold":
  477.               fontFace = {
  478.                 family: family,
  479.                 weight: "bold"
  480.               };
  481.               break;
  483.             case "italic":
  484.               fontFace = {
  485.                 family: family,
  486.                 style: "italic"
  487.               };
  488.               break;
  490.             case "bolditalic":
  491.               fontFace = {
  492.                 family: family,
  493.                 weight: "bold",
  494.                 style: "italic"
  495.               };
  496.               break;
  498.             case "":
  499.             case "normal":
  500.               fontFace = {
  501.                 family: family
  502.               };
  503.               break;
  504.           }
  506.           // If font-face is still null here, it is a font with some styling we don't recognize and
  507.           // cannot map or it is a font added via the fontFaces option of .html().
  508.           if (fontFace !== null) {
  509.             fontFace.ref = {
  510.               name: family,
  511.               style: style
  512.             };
  514.             fontFaces.push(fontFace);
  515.           }
  516.         });
  517.       });
  519.       return fontFaces;
  520.     }
  522.     var _fontFaces = null;
  523.     /**
  524.      * A map of available font-faces, as passed in the options of
  525.      * .html(). If set a limited implementation of the font style matching
  526.      * algorithm defined by https://www.w3.org/TR/css-fonts-3/#font-matching-algorithm
  527.      * will be used. If not set it will fallback to previous behavior.
  528.      */
  530.     Object.defineProperty(this, "fontFaces", {
  531.       get: function() {
  532.         return _fontFaces;
  533.       },
  534.       set: function(value) {
  535.         _fontFaceMap = null;
  536.         _fontFaces = value;
  537.       }
  538.     });
  540.     Object.defineProperty(this, "font", {
  541.       get: function() {
  542.         return this.ctx.font;
  543.       },
  544.       set: function(value) {
  545.         this.ctx.font = value;
  546.         var rx, matches;
  548.         //source: https://stackoverflow.com/a/10136041
  549.         // eslint-disable-next-line no-useless-escape
  550.         rx = /^\s*(?=(?:(?:[-a-z]+\s*){0,2}(italic|oblique))?)(?=(?:(?:[-a-z]+\s*){0,2}(small-caps))?)(?=(?:(?:[-a-z]+\s*){0,2}(bold(?:er)?|lighter|[1-9]00))?)(?:(?:normal|\1|\2|\3)\s*){0,3}((?:xx?-)?(?:small|large)|medium|smaller|larger|[.\d]+(?:\%|in|[cem]m|ex|p[ctx]))(?:\s*\/\s*(normal|[.\d]+(?:\%|in|[cem]m|ex|p[ctx])))?\s*([-_,\"\'\sa-z]+?)\s*$/i;
  551.         matches = rx.exec(value);
  552.         if (matches !== null) {
  553.           var fontStyle = matches[1];
  554.           var fontVariant = matches[2];
  555.           var fontWeight = matches[3];
  556.           var fontSize = matches[4];
  557.           var lineHeight = matches[5];
  558.           var fontFamily = matches[6];
  559.         } else {
  560.           return;
  561.         }
  562.         var rxFontSize = /^([.\d]+)((?:%|in|[cem]m|ex|p[ctx]))$/i;
  563.         var fontSizeUnit = rxFontSize.exec(fontSize)[2];
  565.         if ("px" === fontSizeUnit) {
  566.           fontSize = Math.floor(
  567.             parseFloat(fontSize) * this.pdf.internal.scaleFactor
  568.           );
  569.         } else if ("em" === fontSizeUnit) {
  570.           fontSize = Math.floor(parseFloat(fontSize) * this.pdf.getFontSize());
  571.         } else {
  572.           fontSize = Math.floor(
  573.             parseFloat(fontSize) * this.pdf.internal.scaleFactor
  574.           );
  575.         }
  577.         this.pdf.setFontSize(fontSize);
  578.         var parts = parseFontFamily(fontFamily);
  580.         if (this.fontFaces) {
  581.           var fontFaceMap = getFontFaceMap(this.pdf, this.fontFaces);
  583.           var rules = parts.map(function(ff) {
  584.             return {
  585.               family: ff,
  586.               stretch: "normal", // TODO: Extract font-stretch from font rule (perhaps write proper parser for it?)
  587.               weight: fontWeight,
  588.               style: fontStyle
  589.             };
  590.           });
  592.           var font = resolveFontFace(fontFaceMap, rules);
  593.           this.pdf.setFont(font.ref.name, font.ref.style);
  594.           return;
  595.         }
  597.         var style = "";
  598.         if (
  599.           fontWeight === "bold" ||
  600.           parseInt(fontWeight, 10) >= 700 ||
  601.           fontStyle === "bold"
  602.         ) {
  603.           style = "bold";
  604.         }
  606.         if (fontStyle === "italic") {
  607.           style += "italic";
  608.         }
  610.         if (style.length === 0) {
  611.           style = "normal";
  612.         }
  613.         var jsPdfFontName = "";
  615.         var fallbackFonts = {
  616.           arial: "Helvetica",
  617.           Arial: "Helvetica",
  618.           verdana: "Helvetica",
  619.           Verdana: "Helvetica",
  620.           helvetica: "Helvetica",
  621.           Helvetica: "Helvetica",
  622.           "sans-serif": "Helvetica",
  623.           fixed: "Courier",
  624.           monospace: "Courier",
  625.           terminal: "Courier",
  626.           cursive: "Times",
  627.           fantasy: "Times",
  628.           serif: "Times"
  629.         };
  631.         for (var i = 0; i < parts.length; i++) {
  632.           if (
  633.             this.pdf.internal.getFont(parts[i], style, {
  634.               noFallback: true,
  635.               disableWarning: true
  636.             }) !== undefined
  637.           ) {
  638.             jsPdfFontName = parts[i];
  639.             break;
  640.           } else if (
  641.             style === "bolditalic" &&
  642.             this.pdf.internal.getFont(parts[i], "bold", {
  643.               noFallback: true,
  644.               disableWarning: true
  645.             }) !== undefined
  646.           ) {
  647.             jsPdfFontName = parts[i];
  648.             style = "bold";
  649.           } else if (
  650.             this.pdf.internal.getFont(parts[i], "normal", {
  651.               noFallback: true,
  652.               disableWarning: true
  653.             }) !== undefined
  654.           ) {
  655.             jsPdfFontName = parts[i];
  656.             style = "normal";
  657.             break;
  658.           }
  659.         }
  660.         if (jsPdfFontName === "") {
  661.           for (var j = 0; j < parts.length; j++) {
  662.             if (fallbackFonts[parts[j]]) {
  663.               jsPdfFontName = fallbackFonts[parts[j]];
  664.               break;
  665.             }
  666.           }
  667.         }
  668.         jsPdfFontName = jsPdfFontName === "" ? "Times" : jsPdfFontName;
  669.         this.pdf.setFont(jsPdfFontName, style);
  670.       }
  671.     });
  673.     Object.defineProperty(this, "globalCompositeOperation", {
  674.       get: function() {
  675.         return this.ctx.globalCompositeOperation;
  676.       },
  677.       set: function(value) {
  678.         this.ctx.globalCompositeOperation = value;
  679.       }
  680.     });
  682.     Object.defineProperty(this, "globalAlpha", {
  683.       get: function() {
  684.         return this.ctx.globalAlpha;
  685.       },
  686.       set: function(value) {
  687.         this.ctx.globalAlpha = value;
  688.       }
  689.     });
  691.     /**
  692.      * A float specifying the amount of the line dash offset. The default value is 0.0.
  693.      *
  694.      * @name lineDashOffset
  695.      * @default 0.0
  696.      */
  697.     Object.defineProperty(this, "lineDashOffset", {
  698.       get: function() {
  699.         return this.ctx.lineDashOffset;
  700.       },
  701.       set: function(value) {
  702.         this.ctx.lineDashOffset = value;
  703.         setLineDash.call(this);
  704.       }
  705.     });
  707.     // Not HTML API
  708.     Object.defineProperty(this, "lineDash", {
  709.       get: function() {
  710.         return this.ctx.lineDash;
  711.       },
  712.       set: function(value) {
  713.         this.ctx.lineDash = value;
  714.         setLineDash.call(this);
  715.       }
  716.     });
  718.     // Not HTML API
  719.     Object.defineProperty(this, "ignoreClearRect", {
  720.       get: function() {
  721.         return this.ctx.ignoreClearRect;
  722.       },
  723.       set: function(value) {
  724.         this.ctx.ignoreClearRect = Boolean(value);
  725.       }
  726.     });
  727.   };
  729.   /**
  730.    * Sets the line dash pattern used when stroking lines.
  731.    * @name setLineDash
  732.    * @function
  733.    * @description It uses an array of values that specify alternating lengths of lines and gaps which describe the pattern.
  734.    */
  735.   Context2D.prototype.setLineDash = function(dashArray) {
  736.     this.lineDash = dashArray;
  737.   };
  739.   /**
  740.    * gets the current line dash pattern.
  741.    * @name getLineDash
  742.    * @function
  743.    * @returns {Array} An Array of numbers that specify distances to alternately draw a line and a gap (in coordinate space units). If the number, when setting the elements, is odd, the elements of the array get copied and concatenated. For example, setting the line dash to [5, 15, 25] will result in getting back [5, 15, 25, 5, 15, 25].
  744.    */
  745.   Context2D.prototype.getLineDash = function() {
  746.     if (this.lineDash.length % 2) {
  747.       // https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/getLineDash#return_value
  748.       return this.lineDash.concat(this.lineDash);
  749.     } else {
  750.       // The copied value is returned to prevent contamination from outside.
  751.       return this.lineDash.slice();
  752.     }
  753.   };
  755.   Context2D.prototype.fill = function() {
  756.     pathPreProcess.call(this, "fill", false);
  757.   };
  759.   /**
  760.    * Actually draws the path you have defined
  761.    *
  762.    * @name stroke
  763.    * @function
  764.    * @description The stroke() method actually draws the path you have defined with all those moveTo() and lineTo() methods. The default color is black.
  765.    */
  766.   Context2D.prototype.stroke = function() {
  767.     pathPreProcess.call(this, "stroke", false);
  768.   };
  770.   /**
  771.    * Begins a path, or resets the current
  772.    *
  773.    * @name beginPath
  774.    * @function
  775.    * @description The beginPath() method begins a path, or resets the current path.
  776.    */
  777.   Context2D.prototype.beginPath = function() {
  778.     this.path = [
  779.       {
  780.         type: "begin"
  781.       }
  782.     ];
  783.   };
  785.   /**
  786.    * Moves the path to the specified point in the canvas, without creating a line
  787.    *
  788.    * @name moveTo
  789.    * @function
  790.    * @param x {Number} The x-coordinate of where to move the path to
  791.    * @param y {Number} The y-coordinate of where to move the path to
  792.    */
  793.   Context2D.prototype.moveTo = function(x, y) {
  794.     if (isNaN(x) || isNaN(y)) {
  795.       console.error("jsPDF.context2d.moveTo: Invalid arguments", arguments);
  796.       throw new Error("Invalid arguments passed to jsPDF.context2d.moveTo");
  797.     }
  799.     var pt = this.ctx.transform.applyToPoint(new Point(x, y));
  801.     this.path.push({
  802.       type: "mt",
  803.       x: pt.x,
  804.       y: pt.y
  805.     });
  806.     this.ctx.lastPoint = new Point(x, y);
  807.   };
  809.   /**
  810.    * Creates a path from the current point back to the starting point
  811.    *
  812.    * @name closePath
  813.    * @function
  814.    * @description The closePath() method creates a path from the current point back to the starting point.
  815.    */
  816.   Context2D.prototype.closePath = function() {
  817.     var pathBegin = new Point(0, 0);
  818.     var i = 0;
  819.     for (i = this.path.length - 1; i !== -1; i--) {
  820.       if (this.path[i].type === "begin") {
  821.         if (
  822.           typeof this.path[i + 1] === "object" &&
  823.           typeof this.path[i + 1].x === "number"
  824.         ) {
  825.           pathBegin = new Point(this.path[i + 1].x, this.path[i + 1].y);
  826.           break;
  827.         }
  828.       }
  829.     }
  830.     this.path.push({
  831.       type: "close"
  832.     });
  833.     this.ctx.lastPoint = new Point(pathBegin.x, pathBegin.y);
  834.   };
  836.   /**
  837.    * Adds a new point and creates a line to that point from the last specified point in the canvas
  838.    *
  839.    * @name lineTo
  840.    * @function
  841.    * @param x The x-coordinate of where to create the line to
  842.    * @param y The y-coordinate of where to create the line to
  843.    * @description The lineTo() method adds a new point and creates a line TO that point FROM the last specified point in the canvas (this method does not draw the line).
  844.    */
  845.   Context2D.prototype.lineTo = function(x, y) {
  846.     if (isNaN(x) || isNaN(y)) {
  847.       console.error("jsPDF.context2d.lineTo: Invalid arguments", arguments);
  848.       throw new Error("Invalid arguments passed to jsPDF.context2d.lineTo");
  849.     }
  851.     var pt = this.ctx.transform.applyToPoint(new Point(x, y));
  853.     this.path.push({
  854.       type: "lt",
  855.       x: pt.x,
  856.       y: pt.y
  857.     });
  858.     this.ctx.lastPoint = new Point(pt.x, pt.y);
  859.   };
  861.   /**
  862.    * Clips a region of any shape and size from the original canvas
  863.    *
  864.    * @name clip
  865.    * @function
  866.    * @description The clip() method clips a region of any shape and size from the original canvas.
  867.    */
  868.   Context2D.prototype.clip = function() {
  869.     this.ctx.clip_path = JSON.parse(JSON.stringify(this.path));
  870.     pathPreProcess.call(this, null, true);
  871.   };
  873.   /**
  874.    * Creates a cubic Bézier curve
  875.    *
  876.    * @name quadraticCurveTo
  877.    * @function
  878.    * @param cpx {Number} The x-coordinate of the Bézier control point
  879.    * @param cpy {Number} The y-coordinate of the Bézier control point
  880.    * @param x {Number} The x-coordinate of the ending point
  881.    * @param y {Number} The y-coordinate of the ending point
  882.    * @description The quadraticCurveTo() method adds a point to the current path by using the specified control points that represent a quadratic Bézier curve.<br /><br /> A quadratic Bézier curve requires two points. The first point is a control point that is used in the quadratic Bézier calculation and the second point is the ending point for the curve. The starting point for the curve is the last point in the current path. If a path does not exist, use the beginPath() and moveTo() methods to define a starting point.
  883.    */
  884.   Context2D.prototype.quadraticCurveTo = function(cpx, cpy, x, y) {
  885.     if (isNaN(x) || isNaN(y) || isNaN(cpx) || isNaN(cpy)) {
  886.       console.error(
  887.         "jsPDF.context2d.quadraticCurveTo: Invalid arguments",
  888.         arguments
  889.       );
  890.       throw new Error(
  891.         "Invalid arguments passed to jsPDF.context2d.quadraticCurveTo"
  892.       );
  893.     }
  895.     var pt0 = this.ctx.transform.applyToPoint(new Point(x, y));
  896.     var pt1 = this.ctx.transform.applyToPoint(new Point(cpx, cpy));
  898.     this.path.push({
  899.       type: "qct",
  900.       x1: pt1.x,
  901.       y1: pt1.y,
  902.       x: pt0.x,
  903.       y: pt0.y
  904.     });
  905.     this.ctx.lastPoint = new Point(pt0.x, pt0.y);
  906.   };
  908.   /**
  909.    * Creates a cubic Bézier curve
  910.    *
  911.    * @name bezierCurveTo
  912.    * @function
  913.    * @param cp1x {Number} The x-coordinate of the first Bézier control point
  914.    * @param cp1y {Number} The y-coordinate of the first Bézier control point
  915.    * @param cp2x {Number} The x-coordinate of the second Bézier control point
  916.    * @param cp2y {Number} The y-coordinate of the second Bézier control point
  917.    * @param x {Number} The x-coordinate of the ending point
  918.    * @param y {Number} The y-coordinate of the ending point
  919.    * @description The bezierCurveTo() method adds a point to the current path by using the specified control points that represent a cubic Bézier curve. <br /><br />A cubic bezier curve requires three points. The first two points are control points that are used in the cubic Bézier calculation and the last point is the ending point for the curve.  The starting point for the curve is the last point in the current path. If a path does not exist, use the beginPath() and moveTo() methods to define a starting point.
  920.    */
  921.   Context2D.prototype.bezierCurveTo = function(cp1x, cp1y, cp2x, cp2y, x, y) {
  922.     if (
  923.       isNaN(x) ||
  924.       isNaN(y) ||
  925.       isNaN(cp1x) ||
  926.       isNaN(cp1y) ||
  927.       isNaN(cp2x) ||
  928.       isNaN(cp2y)
  929.     ) {
  930.       console.error(
  931.         "jsPDF.context2d.bezierCurveTo: Invalid arguments",
  932.         arguments
  933.       );
  934.       throw new Error(
  935.         "Invalid arguments passed to jsPDF.context2d.bezierCurveTo"
  936.       );
  937.     }
  938.     var pt0 = this.ctx.transform.applyToPoint(new Point(x, y));
  939.     var pt1 = this.ctx.transform.applyToPoint(new Point(cp1x, cp1y));
  940.     var pt2 = this.ctx.transform.applyToPoint(new Point(cp2x, cp2y));
  942.     this.path.push({
  943.       type: "bct",
  944.       x1: pt1.x,
  945.       y1: pt1.y,
  946.       x2: pt2.x,
  947.       y2: pt2.y,
  948.       x: pt0.x,
  949.       y: pt0.y
  950.     });
  951.     this.ctx.lastPoint = new Point(pt0.x, pt0.y);
  952.   };
  954.   /**
  955.    * Creates an arc/curve (used to create circles, or parts of circles)
  956.    *
  957.    * @name arc
  958.    * @function
  959.    * @param x {Number} The x-coordinate of the center of the circle
  960.    * @param y {Number} The y-coordinate of the center of the circle
  961.    * @param radius {Number} The radius of the circle
  962.    * @param startAngle {Number} The starting angle, in radians (0 is at the 3 o'clock position of the arc's circle)
  963.    * @param endAngle {Number} The ending angle, in radians
  964.    * @param counterclockwise {Boolean} Optional. Specifies whether the drawing should be counterclockwise or clockwise. False is default, and indicates clockwise, while true indicates counter-clockwise.
  965.    * @description The arc() method creates an arc/curve (used to create circles, or parts of circles).
  966.    */
  967.   Context2D.prototype.arc = function(
  968.     x,
  969.     y,
  970.     radius,
  971.     startAngle,
  972.     endAngle,
  973.     counterclockwise
  974.   ) {
  975.     if (
  976.       isNaN(x) ||
  977.       isNaN(y) ||
  978.       isNaN(radius) ||
  979.       isNaN(startAngle) ||
  980.       isNaN(endAngle)
  981.     ) {
  982.       console.error("jsPDF.context2d.arc: Invalid arguments", arguments);
  983.       throw new Error("Invalid arguments passed to jsPDF.context2d.arc");
  984.     }
  985.     counterclockwise = Boolean(counterclockwise);
  987.     if (!this.ctx.transform.isIdentity) {
  988.       var xpt = this.ctx.transform.applyToPoint(new Point(x, y));
  989.       x = xpt.x;
  990.       y = xpt.y;
  992.       var x_radPt = this.ctx.transform.applyToPoint(new Point(0, radius));
  993.       var x_radPt0 = this.ctx.transform.applyToPoint(new Point(0, 0));
  994.       radius = Math.sqrt(
  995.         Math.pow(x_radPt.x - x_radPt0.x, 2) +
  996.           Math.pow(x_radPt.y - x_radPt0.y, 2)
  997.       );
  998.     }
  999.     if (Math.abs(endAngle - startAngle) >= 2 * Math.PI) {
  1000.       startAngle = 0;
  1001.       endAngle = 2 * Math.PI;
  1002.     }
  1004.     this.path.push({
  1005.       type: "arc",
  1006.       x: x,
  1007.       y: y,
  1008.       radius: radius,
  1009.       startAngle: startAngle,
  1010.       endAngle: endAngle,
  1011.       counterclockwise: counterclockwise
  1012.     });
  1013.     // this.ctx.lastPoint(new Point(pt.x,pt.y));
  1014.   };
  1016.   /**
  1017.    * Creates an arc/curve between two tangents
  1018.    *
  1019.    * @name arcTo
  1020.    * @function
  1021.    * @param x1 {Number} The x-coordinate of the first tangent
  1022.    * @param y1 {Number} The y-coordinate of the first tangent
  1023.    * @param x2 {Number} The x-coordinate of the second tangent
  1024.    * @param y2 {Number} The y-coordinate of the second tangent
  1025.    * @param radius The radius of the arc
  1026.    * @description The arcTo() method creates an arc/curve between two tangents on the canvas.
  1027.    */
  1028.   // eslint-disable-next-line no-unused-vars
  1029.   Context2D.prototype.arcTo = function(x1, y1, x2, y2, radius) {
  1030.     throw new Error("arcTo not implemented.");
  1031.   };
  1033.   /**
  1034.    * Creates a rectangle
  1035.    *
  1036.    * @name rect
  1037.    * @function
  1038.    * @param x {Number} The x-coordinate of the upper-left corner of the rectangle
  1039.    * @param y {Number} The y-coordinate of the upper-left corner of the rectangle
  1040.    * @param w {Number} The width of the rectangle, in pixels
  1041.    * @param h {Number} The height of the rectangle, in pixels
  1042.    * @description The rect() method creates a rectangle.
  1043.    */
  1044.   Context2D.prototype.rect = function(x, y, w, h) {
  1045.     if (isNaN(x) || isNaN(y) || isNaN(w) || isNaN(h)) {
  1046.       console.error("jsPDF.context2d.rect: Invalid arguments", arguments);
  1047.       throw new Error("Invalid arguments passed to jsPDF.context2d.rect");
  1048.     }
  1049.     this.moveTo(x, y);
  1050.     this.lineTo(x + w, y);
  1051.     this.lineTo(x + w, y + h);
  1052.     this.lineTo(x, y + h);
  1053.     this.lineTo(x, y);
  1054.     this.lineTo(x + w, y);
  1055.     this.lineTo(x, y);
  1056.   };
  1058.   /**
  1059.    * Draws a "filled" rectangle
  1060.    *
  1061.    * @name fillRect
  1062.    * @function
  1063.    * @param x {Number} The x-coordinate of the upper-left corner of the rectangle
  1064.    * @param y {Number} The y-coordinate of the upper-left corner of the rectangle
  1065.    * @param w {Number} The width of the rectangle, in pixels
  1066.    * @param h {Number} The height of the rectangle, in pixels
  1067.    * @description The fillRect() method draws a "filled" rectangle. The default color of the fill is black.
  1068.    */
  1069.   Context2D.prototype.fillRect = function(x, y, w, h) {
  1070.     if (isNaN(x) || isNaN(y) || isNaN(w) || isNaN(h)) {
  1071.       console.error("jsPDF.context2d.fillRect: Invalid arguments", arguments);
  1072.       throw new Error("Invalid arguments passed to jsPDF.context2d.fillRect");
  1073.     }
  1074.     if (isFillTransparent.call(this)) {
  1075.       return;
  1076.     }
  1077.     var tmp = {};
  1078.     if (this.lineCap !== "butt") {
  1079.       tmp.lineCap = this.lineCap;
  1080.       this.lineCap = "butt";
  1081.     }
  1082.     if (this.lineJoin !== "miter") {
  1083.       tmp.lineJoin = this.lineJoin;
  1084.       this.lineJoin = "miter";
  1085.     }
  1087.     this.beginPath();
  1088.     this.rect(x, y, w, h);
  1089.     this.fill();
  1091.     if (tmp.hasOwnProperty("lineCap")) {
  1092.       this.lineCap = tmp.lineCap;
  1093.     }
  1094.     if (tmp.hasOwnProperty("lineJoin")) {
  1095.       this.lineJoin = tmp.lineJoin;
  1096.     }
  1097.   };
  1099.   /**
  1100.    *     Draws a rectangle (no fill)
  1101.    *
  1102.    * @name strokeRect
  1103.    * @function
  1104.    * @param x {Number} The x-coordinate of the upper-left corner of the rectangle
  1105.    * @param y {Number} The y-coordinate of the upper-left corner of the rectangle
  1106.    * @param w {Number} The width of the rectangle, in pixels
  1107.    * @param h {Number} The height of the rectangle, in pixels
  1108.    * @description The strokeRect() method draws a rectangle (no fill). The default color of the stroke is black.
  1109.    */
  1110.   Context2D.prototype.strokeRect = function strokeRect(x, y, w, h) {
  1111.     if (isNaN(x) || isNaN(y) || isNaN(w) || isNaN(h)) {
  1112.       console.error("jsPDF.context2d.strokeRect: Invalid arguments", arguments);
  1113.       throw new Error("Invalid arguments passed to jsPDF.context2d.strokeRect");
  1114.     }
  1115.     if (isStrokeTransparent.call(this)) {
  1116.       return;
  1117.     }
  1118.     this.beginPath();
  1119.     this.rect(x, y, w, h);
  1120.     this.stroke();
  1121.   };
  1123.   /**
  1124.    * Clears the specified pixels within a given rectangle
  1125.    *
  1126.    * @name clearRect
  1127.    * @function
  1128.    * @param x {Number} The x-coordinate of the upper-left corner of the rectangle
  1129.    * @param y {Number} The y-coordinate of the upper-left corner of the rectangle
  1130.    * @param w {Number} The width of the rectangle to clear, in pixels
  1131.    * @param h {Number} The height of the rectangle to clear, in pixels
  1132.    * @description We cannot clear PDF commands that were already written to PDF, so we use white instead. <br />
  1133.    * As a special case, read a special flag (ignoreClearRect) and do nothing if it is set.
  1134.    * This results in all calls to clearRect() to do nothing, and keep the canvas transparent.
  1135.    * This flag is stored in the save/restore context and is managed the same way as other drawing states.
  1136.    *
  1137.    */
  1138.   Context2D.prototype.clearRect = function(x, y, w, h) {
  1139.     if (isNaN(x) || isNaN(y) || isNaN(w) || isNaN(h)) {
  1140.       console.error("jsPDF.context2d.clearRect: Invalid arguments", arguments);
  1141.       throw new Error("Invalid arguments passed to jsPDF.context2d.clearRect");
  1142.     }
  1143.     if (this.ignoreClearRect) {
  1144.       return;
  1145.     }
  1147.     this.fillStyle = "#ffffff";
  1148.     this.fillRect(x, y, w, h);
  1149.   };
  1151.   /**
  1152.    * Saves the state of the current context
  1153.    *
  1154.    * @name save
  1155.    * @function
  1156.    */
  1157.   Context2D.prototype.save = function(doStackPush) {
  1158.     doStackPush = typeof doStackPush === "boolean" ? doStackPush : true;
  1159.     var tmpPageNumber = this.pdf.internal.getCurrentPageInfo().pageNumber;
  1160.     for (var i = 0; i < this.pdf.internal.getNumberOfPages(); i++) {
  1161.       this.pdf.setPage(i + 1);
  1162.       this.pdf.internal.out("q");
  1163.     }
  1164.     this.pdf.setPage(tmpPageNumber);
  1166.     if (doStackPush) {
  1167.       this.ctx.fontSize = this.pdf.internal.getFontSize();
  1168.       var ctx = new ContextLayer(this.ctx);
  1169.       this.ctxStack.push(this.ctx);
  1170.       this.ctx = ctx;
  1171.     }
  1172.   };
  1174.   /**
  1175.    * Returns previously saved path state and attributes
  1176.    *
  1177.    * @name restore
  1178.    * @function
  1179.    */
  1180.   Context2D.prototype.restore = function(doStackPop) {
  1181.     doStackPop = typeof doStackPop === "boolean" ? doStackPop : true;
  1182.     var tmpPageNumber = this.pdf.internal.getCurrentPageInfo().pageNumber;
  1183.     for (var i = 0; i < this.pdf.internal.getNumberOfPages(); i++) {
  1184.       this.pdf.setPage(i + 1);
  1185.       this.pdf.internal.out("Q");
  1186.     }
  1187.     this.pdf.setPage(tmpPageNumber);
  1189.     if (doStackPop && this.ctxStack.length !== 0) {
  1190.       this.ctx = this.ctxStack.pop();
  1191.       this.fillStyle = this.ctx.fillStyle;
  1192.       this.strokeStyle = this.ctx.strokeStyle;
  1193.       this.font = this.ctx.font;
  1194.       this.lineCap = this.ctx.lineCap;
  1195.       this.lineWidth = this.ctx.lineWidth;
  1196.       this.lineJoin = this.ctx.lineJoin;
  1197.       this.lineDash = this.ctx.lineDash;
  1198.       this.lineDashOffset = this.ctx.lineDashOffset;
  1199.     }
  1200.   };
  1202.   /**
  1203.    * @name toDataURL
  1204.    * @function
  1205.    */
  1206.   Context2D.prototype.toDataURL = function() {
  1207.     throw new Error("toDataUrl not implemented.");
  1208.   };
  1210.   //helper functions
  1212.   /**
  1213.    * Get the decimal values of r, g, b and a
  1214.    *
  1215.    * @name getRGBA
  1216.    * @function
  1217.    * @private
  1218.    * @ignore
  1219.    */
  1220.   var getRGBA = function(style) {
  1221.     var rxRgb = /rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/;
  1222.     var rxRgba = /rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d.]+)\s*\)/;
  1223.     var rxTransparent = /transparent|rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*0+\s*\)/;
  1225.     var r, g, b, a;
  1227.     if (style.isCanvasGradient === true) {
  1228.       style = style.getColor();
  1229.     }
  1231.     if (!style) {
  1232.       return { r: 0, g: 0, b: 0, a: 0, style: style };
  1233.     }
  1235.     if (rxTransparent.test(style)) {
  1236.       r = 0;
  1237.       g = 0;
  1238.       b = 0;
  1239.       a = 0;
  1240.     } else {
  1241.       var matches = rxRgb.exec(style);
  1242.       if (matches !== null) {
  1243.         r = parseInt(matches[1]);
  1244.         g = parseInt(matches[2]);
  1245.         b = parseInt(matches[3]);
  1246.         a = 1;
  1247.       } else {
  1248.         matches = rxRgba.exec(style);
  1249.         if (matches !== null) {
  1250.           r = parseInt(matches[1]);
  1251.           g = parseInt(matches[2]);
  1252.           b = parseInt(matches[3]);
  1253.           a = parseFloat(matches[4]);
  1254.         } else {
  1255.           a = 1;
  1257.           if (typeof style === "string" && style.charAt(0) !== "#") {
  1258.             var rgbColor = new RGBColor(style);
  1259.             if (rgbColor.ok) {
  1260.               style = rgbColor.toHex();
  1261.             } else {
  1262.               style = "#000000";
  1263.             }
  1264.           }
  1266.           if (style.length === 4) {
  1267.             r = style.substring(1, 2);
  1268.             r += r;
  1269.             g = style.substring(2, 3);
  1270.             g += g;
  1271.             b = style.substring(3, 4);
  1272.             b += b;
  1273.           } else {
  1274.             r = style.substring(1, 3);
  1275.             g = style.substring(3, 5);
  1276.             b = style.substring(5, 7);
  1277.           }
  1278.           r = parseInt(r, 16);
  1279.           g = parseInt(g, 16);
  1280.           b = parseInt(b, 16);
  1281.         }
  1282.       }
  1283.     }
  1284.     return { r: r, g: g, b: b, a: a, style: style };
  1285.   };
  1287.   /**
  1288.    * @name isFillTransparent
  1289.    * @function
  1290.    * @private
  1291.    * @ignore
  1292.    * @returns {Boolean}
  1293.    */
  1294.   var isFillTransparent = function() {
  1295.     return this.ctx.isFillTransparent || this.globalAlpha == 0;
  1296.   };
  1298.   /**
  1299.    * @name isStrokeTransparent
  1300.    * @function
  1301.    * @private
  1302.    * @ignore
  1303.    * @returns {Boolean}
  1304.    */
  1305.   var isStrokeTransparent = function() {
  1306.     return Boolean(this.ctx.isStrokeTransparent || this.globalAlpha == 0);
  1307.   };
  1309.   /**
  1310.    * Draws "filled" text on the canvas
  1311.    *
  1312.    * @name fillText
  1313.    * @function
  1314.    * @param text {String} Specifies the text that will be written on the canvas
  1315.    * @param x {Number} The x coordinate where to start painting the text (relative to the canvas)
  1316.    * @param y {Number} The y coordinate where to start painting the text (relative to the canvas)
  1317.    * @param maxWidth {Number} Optional. The maximum allowed width of the text, in pixels
  1318.    * @description The fillText() method draws filled text on the canvas. The default color of the text is black.
  1319.    */
  1320.   Context2D.prototype.fillText = function(text, x, y, maxWidth) {
  1321.     if (isNaN(x) || isNaN(y) || typeof text !== "string") {
  1322.       console.error("jsPDF.context2d.fillText: Invalid arguments", arguments);
  1323.       throw new Error("Invalid arguments passed to jsPDF.context2d.fillText");
  1324.     }
  1325.     maxWidth = isNaN(maxWidth) ? undefined : maxWidth;
  1326.     if (isFillTransparent.call(this)) {
  1327.       return;
  1328.     }
  1330.     var degs = rad2deg(this.ctx.transform.rotation);
  1332.     // We only use X axis as scale hint
  1333.     var scale = this.ctx.transform.scaleX;
  1335.     putText.call(this, {
  1336.       text: text,
  1337.       x: x,
  1338.       y: y,
  1339.       scale: scale,
  1340.       angle: degs,
  1341.       align: this.textAlign,
  1342.       maxWidth: maxWidth
  1343.     });
  1344.   };
  1346.   /**
  1347.    * Draws text on the canvas (no fill)
  1348.    *
  1349.    * @name strokeText
  1350.    * @function
  1351.    * @param text {String} Specifies the text that will be written on the canvas
  1352.    * @param x {Number} The x coordinate where to start painting the text (relative to the canvas)
  1353.    * @param y {Number} The y coordinate where to start painting the text (relative to the canvas)
  1354.    * @param maxWidth {Number} Optional. The maximum allowed width of the text, in pixels
  1355.    * @description The strokeText() method draws text (with no fill) on the canvas. The default color of the text is black.
  1356.    */
  1357.   Context2D.prototype.strokeText = function(text, x, y, maxWidth) {
  1358.     if (isNaN(x) || isNaN(y) || typeof text !== "string") {
  1359.       console.error("jsPDF.context2d.strokeText: Invalid arguments", arguments);
  1360.       throw new Error("Invalid arguments passed to jsPDF.context2d.strokeText");
  1361.     }
  1362.     if (isStrokeTransparent.call(this)) {
  1363.       return;
  1364.     }
  1366.     maxWidth = isNaN(maxWidth) ? undefined : maxWidth;
  1368.     var degs = rad2deg(this.ctx.transform.rotation);
  1369.     var scale = this.ctx.transform.scaleX;
  1371.     putText.call(this, {
  1372.       text: text,
  1373.       x: x,
  1374.       y: y,
  1375.       scale: scale,
  1376.       renderingMode: "stroke",
  1377.       angle: degs,
  1378.       align: this.textAlign,
  1379.       maxWidth: maxWidth
  1380.     });
  1381.   };
  1383.   /**
  1384.    * Returns an object that contains the width of the specified text
  1385.    *
  1386.    * @name measureText
  1387.    * @function
  1388.    * @param text {String} The text to be measured
  1389.    * @description The measureText() method returns an object that contains the width of the specified text, in pixels.
  1390.    * @returns {Number}
  1391.    */
  1392.   Context2D.prototype.measureText = function(text) {
  1393.     if (typeof text !== "string") {
  1394.       console.error(
  1395.         "jsPDF.context2d.measureText: Invalid arguments",
  1396.         arguments
  1397.       );
  1398.       throw new Error(
  1399.         "Invalid arguments passed to jsPDF.context2d.measureText"
  1400.       );
  1401.     }
  1402.     var pdf = this.pdf;
  1403.     var k = this.pdf.internal.scaleFactor;
  1405.     var fontSize = pdf.internal.getFontSize();
  1406.     var txtWidth =
  1407.       (pdf.getStringUnitWidth(text) * fontSize) / pdf.internal.scaleFactor;
  1408.     txtWidth *= Math.round(((k * 96) / 72) * 10000) / 10000;
  1410.     var TextMetrics = function(options) {
  1411.       options = options || {};
  1412.       var _width = options.width || 0;
  1413.       Object.defineProperty(this, "width", {
  1414.         get: function() {
  1415.           return _width;
  1416.         }
  1417.       });
  1418.       return this;
  1419.     };
  1420.     return new TextMetrics({ width: txtWidth });
  1421.   };
  1423.   //Transformations
  1425.   /**
  1426.    * Scales the current drawing bigger or smaller
  1427.    *
  1428.    * @name scale
  1429.    * @function
  1430.    * @param scalewidth {Number} Scales the width of the current drawing (1=100%, 0.5=50%, 2=200%, etc.)
  1431.    * @param scaleheight {Number} Scales the height of the current drawing (1=100%, 0.5=50%, 2=200%, etc.)
  1432.    * @description The scale() method scales the current drawing, bigger or smaller.
  1433.    */
  1434.   Context2D.prototype.scale = function(scalewidth, scaleheight) {
  1435.     if (isNaN(scalewidth) || isNaN(scaleheight)) {
  1436.       console.error("jsPDF.context2d.scale: Invalid arguments", arguments);
  1437.       throw new Error("Invalid arguments passed to jsPDF.context2d.scale");
  1438.     }
  1439.     var matrix = new Matrix(scalewidth, 0.0, 0.0, scaleheight, 0.0, 0.0);
  1440.     this.ctx.transform = this.ctx.transform.multiply(matrix);
  1441.   };
  1443.   /**
  1444.    * Rotates the current drawing
  1445.    *
  1446.    * @name rotate
  1447.    * @function
  1448.    * @param angle {Number} The rotation angle, in radians.
  1449.    * @description To calculate from degrees to radians: degrees*Math.PI/180. <br />
  1450.    * Example: to rotate 5 degrees, specify the following: 5*Math.PI/180
  1451.    */
  1452.   Context2D.prototype.rotate = function(angle) {
  1453.     if (isNaN(angle)) {
  1454.       console.error("jsPDF.context2d.rotate: Invalid arguments", arguments);
  1455.       throw new Error("Invalid arguments passed to jsPDF.context2d.rotate");
  1456.     }
  1457.     var matrix = new Matrix(
  1458.       Math.cos(angle),
  1459.       Math.sin(angle),
  1460.       -Math.sin(angle),
  1461.       Math.cos(angle),
  1462.       0.0,
  1463.       0.0
  1464.     );
  1465.     this.ctx.transform = this.ctx.transform.multiply(matrix);
  1466.   };
  1468.   /**
  1469.    * Remaps the (0,0) position on the canvas
  1470.    *
  1471.    * @name translate
  1472.    * @function
  1473.    * @param x {Number} The value to add to horizontal (x) coordinates
  1474.    * @param y {Number} The value to add to vertical (y) coordinates
  1475.    * @description The translate() method remaps the (0,0) position on the canvas.
  1476.    */
  1477.   Context2D.prototype.translate = function(x, y) {
  1478.     if (isNaN(x) || isNaN(y)) {
  1479.       console.error("jsPDF.context2d.translate: Invalid arguments", arguments);
  1480.       throw new Error("Invalid arguments passed to jsPDF.context2d.translate");
  1481.     }
  1482.     var matrix = new Matrix(1.0, 0.0, 0.0, 1.0, x, y);
  1483.     this.ctx.transform = this.ctx.transform.multiply(matrix);
  1484.   };
  1486.   /**
  1487.    * Replaces the current transformation matrix for the drawing
  1488.    *
  1489.    * @name transform
  1490.    * @function
  1491.    * @param a {Number} Horizontal scaling
  1492.    * @param b {Number} Horizontal skewing
  1493.    * @param c {Number} Vertical skewing
  1494.    * @param d {Number} Vertical scaling
  1495.    * @param e {Number} Horizontal moving
  1496.    * @param f {Number} Vertical moving
  1497.    * @description Each object on the canvas has a current transformation matrix.<br /><br />The transform() method replaces the current transformation matrix. It multiplies the current transformation matrix with the matrix described by:<br /><br /><br /><br />a    c    e<br /><br />b    d    f<br /><br />0    0    1<br /><br />In other words, the transform() method lets you scale, rotate, move, and skew the current context.
  1498.    */
  1499.   Context2D.prototype.transform = function(a, b, c, d, e, f) {
  1500.     if (isNaN(a) || isNaN(b) || isNaN(c) || isNaN(d) || isNaN(e) || isNaN(f)) {
  1501.       console.error("jsPDF.context2d.transform: Invalid arguments", arguments);
  1502.       throw new Error("Invalid arguments passed to jsPDF.context2d.transform");
  1503.     }
  1504.     var matrix = new Matrix(a, b, c, d, e, f);
  1505.     this.ctx.transform = this.ctx.transform.multiply(matrix);
  1506.   };
  1508.   /**
  1509.    * Resets the current transform to the identity matrix. Then runs transform()
  1510.    *
  1511.    * @name setTransform
  1512.    * @function
  1513.    * @param a {Number} Horizontal scaling
  1514.    * @param b {Number} Horizontal skewing
  1515.    * @param c {Number} Vertical skewing
  1516.    * @param d {Number} Vertical scaling
  1517.    * @param e {Number} Horizontal moving
  1518.    * @param f {Number} Vertical moving
  1519.    * @description Each object on the canvas has a current transformation matrix. <br /><br />The setTransform() method resets the current transform to the identity matrix, and then runs transform() with the same arguments.<br /><br />In other words, the setTransform() method lets you scale, rotate, move, and skew the current context.
  1520.    */
  1521.   Context2D.prototype.setTransform = function(a, b, c, d, e, f) {
  1522.     a = isNaN(a) ? 1 : a;
  1523.     b = isNaN(b) ? 0 : b;
  1524.     c = isNaN(c) ? 0 : c;
  1525.     d = isNaN(d) ? 1 : d;
  1526.     e = isNaN(e) ? 0 : e;
  1527.     f = isNaN(f) ? 0 : f;
  1528.     this.ctx.transform = new Matrix(a, b, c, d, e, f);
  1529.   };
  1531.   /**
  1532.    * Should only be used if pageWrapYEnabled is true
  1533.    *
  1534.    * @name setPageByYPosition
  1535.    * @function
  1536.    * @private
  1537.    * @ignore
  1538.    * @returns One-based Page Number
  1539.    */
  1540.   var setPageByYPosition = function(y) {
  1541.     if (this.pageWrapYEnabled) {
  1542.       this.lastBreak = 0;
  1543.       var manualBreaks = 0;
  1544.       var autoBreaks = 0;
  1545.       for (var i = 0; i < this.pageBreaks.length; i++) {
  1546.         if (y >= this.pageBreaks[i]) {
  1547.           manualBreaks++;
  1548.           if (this.lastBreak === 0) {
  1549.             autoBreaks++;
  1550.           }
  1551.           var spaceBetweenLastBreak = this.pageBreaks[i] - this.lastBreak;
  1552.           this.lastBreak = this.pageBreaks[i];
  1553.           var pagesSinceLastBreak = Math.floor(
  1554.             spaceBetweenLastBreak / this.pageWrapY
  1555.           );
  1556.           autoBreaks += pagesSinceLastBreak;
  1557.         }
  1558.       }
  1559.       if (this.lastBreak === 0) {
  1560.         var pagesSinceLastBreak = Math.floor(y / this.pageWrapY) + 1;
  1561.         autoBreaks += pagesSinceLastBreak;
  1562.       }
  1563.       return autoBreaks + manualBreaks;
  1564.     } else {
  1565.       return this.pdf.internal.getCurrentPageInfo().pageNumber;
  1566.     }
  1567.   };
  1569.   var hasMargins = function() {
  1570.     return (
  1571.       this.margin[0] > 0 ||
  1572.       this.margin[1] > 0 ||
  1573.       this.margin[2] > 0 ||
  1574.       this.margin[3] > 0
  1575.     );
  1576.   };
  1578.   /**
  1579.    * Draws an image, canvas, or video onto the canvas
  1580.    *
  1581.    * @function
  1582.    * @param img {} Specifies the image, canvas, or video element to use
  1583.    * @param sx {Number} Optional. The x coordinate where to start clipping
  1584.    * @param sy {Number} Optional. The y coordinate where to start clipping
  1585.    * @param swidth {Number} Optional. The width of the clipped image
  1586.    * @param sheight {Number} Optional. The height of the clipped image
  1587.    * @param x {Number} The x coordinate where to place the image on the canvas
  1588.    * @param y {Number} The y coordinate where to place the image on the canvas
  1589.    * @param width {Number} Optional. The width of the image to use (stretch or reduce the image)
  1590.    * @param height {Number} Optional. The height of the image to use (stretch or reduce the image)
  1591.    */
  1592.   Context2D.prototype.drawImage = function(
  1593.     img,
  1594.     sx,
  1595.     sy,
  1596.     swidth,
  1597.     sheight,
  1598.     x,
  1599.     y,
  1600.     width,
  1601.     height
  1602.   ) {
  1603.     var imageProperties = this.pdf.getImageProperties(img);
  1604.     var factorX = 1;
  1605.     var factorY = 1;
  1606.     var isClip;
  1608.     var clipFactorX = 1;
  1609.     var clipFactorY = 1;
  1611.     if (typeof swidth !== "undefined" && typeof width !== "undefined") {
  1612.       isClip = true;
  1613.       clipFactorX = width / swidth;
  1614.       clipFactorY = height / sheight;
  1615.       factorX = ((imageProperties.width / swidth) * width) / swidth;
  1616.       factorY = ((imageProperties.height / sheight) * height) / sheight;
  1617.     }
  1619.     //is sx and sy are set and x and y not, set x and y with values of sx and sy
  1620.     if (typeof x === "undefined") {
  1621.       x = sx;
  1622.       y = sy;
  1623.       sx = 0;
  1624.       sy = 0;
  1625.     }
  1627.     if (typeof swidth !== "undefined" && typeof width === "undefined") {
  1628.       width = swidth;
  1629.       height = sheight;
  1630.     }
  1631.     if (typeof swidth === "undefined" && typeof width === "undefined") {
  1632.       width = imageProperties.width;
  1633.       height = imageProperties.height;
  1634.     }
  1636.     var decomposedTransformationMatrix = this.ctx.transform.decompose();
  1637.     var angle = rad2deg(decomposedTransformationMatrix.rotate.shx);
  1638.     var matrix = new Matrix();
  1639.     matrix = matrix.multiply(decomposedTransformationMatrix.translate);
  1640.     matrix = matrix.multiply(decomposedTransformationMatrix.skew);
  1641.     matrix = matrix.multiply(decomposedTransformationMatrix.scale);
  1642.     var xRect = matrix.applyToRectangle(
  1643.       new Rectangle(
  1644.         x - sx * clipFactorX,
  1645.         y - sy * clipFactorY,
  1646.         swidth * factorX,
  1647.         sheight * factorY
  1648.       )
  1649.     );
  1650.     var pageArray = getPagesByPath.call(this, xRect);
  1651.     var pages = [];
  1652.     for (var ii = 0; ii < pageArray.length; ii += 1) {
  1653.       if (pages.indexOf(pageArray[ii]) === -1) {
  1654.         pages.push(pageArray[ii]);
  1655.       }
  1656.     }
  1658.     sortPages(pages);
  1660.     var clipPath;
  1661.     if (this.autoPaging) {
  1662.       var min = pages[0];
  1663.       var max = pages[pages.length - 1];
  1664.       for (var i = min; i < max + 1; i++) {
  1665.         this.pdf.setPage(i);
  1667.         var pageWidthMinusMargins =
  1668.           this.pdf.internal.pageSize.width - this.margin[3] - this.margin[1];
  1669.         var topMargin = i === 1 ? this.posY + this.margin[0] : this.margin[0];
  1670.         var firstPageHeight =
  1671.           this.pdf.internal.pageSize.height -
  1672.           this.posY -
  1673.           this.margin[0] -
  1674.           this.margin[2];
  1675.         var pageHeightMinusMargins =
  1676.           this.pdf.internal.pageSize.height - this.margin[0] - this.margin[2];
  1677.         var previousPageHeightSum =
  1678.           i === 1 ? 0 : firstPageHeight + (i - 2) * pageHeightMinusMargins;
  1680.         if (this.ctx.clip_path.length !== 0) {
  1681.           var tmpPaths = this.path;
  1682.           clipPath = JSON.parse(JSON.stringify(this.ctx.clip_path));
  1683.           this.path = pathPositionRedo(
  1684.             clipPath,
  1685.             this.posX + this.margin[3],
  1686.             -previousPageHeightSum + topMargin + this.ctx.prevPageLastElemOffset
  1687.           );
  1688.           drawPaths.call(this, "fill", true);
  1689.           this.path = tmpPaths;
  1690.         }
  1691.         var tmpRect = JSON.parse(JSON.stringify(xRect));
  1692.         tmpRect = pathPositionRedo(
  1693.           [tmpRect],
  1694.           this.posX + this.margin[3],
  1695.           -previousPageHeightSum + topMargin + this.ctx.prevPageLastElemOffset
  1696.         )[0];
  1698.         const needsClipping = (i > min || i < max) && hasMargins.call(this);
  1700.         if (needsClipping) {
  1701.           this.pdf.saveGraphicsState();
  1702.           this.pdf
  1703.             .rect(
  1704.               this.margin[3],
  1705.               this.margin[0],
  1706.               pageWidthMinusMargins,
  1707.               pageHeightMinusMargins,
  1708.               null
  1709.             )
  1710.             .clip()
  1711.             .discardPath();
  1712.         }
  1713.         this.pdf.addImage(
  1714.           img,
  1715.           "JPEG",
  1716.           tmpRect.x,
  1717.           tmpRect.y,
  1718.           tmpRect.w,
  1719.           tmpRect.h,
  1720.           null,
  1721.           null,
  1722.           angle
  1723.         );
  1724.         if (needsClipping) {
  1725.           this.pdf.restoreGraphicsState();
  1726.         }
  1727.       }
  1728.     } else {
  1729.       this.pdf.addImage(
  1730.         img,
  1731.         "JPEG",
  1732.         xRect.x,
  1733.         xRect.y,
  1734.         xRect.w,
  1735.         xRect.h,
  1736.         null,
  1737.         null,
  1738.         angle
  1739.       );
  1740.     }
  1741.   };
  1743.   var getPagesByPath = function(path, pageWrapX, pageWrapY) {
  1744.     var result = [];
  1745.     pageWrapX = pageWrapX || this.pdf.internal.pageSize.width;
  1746.     pageWrapY =
  1747.       pageWrapY ||
  1748.       this.pdf.internal.pageSize.height - this.margin[0] - this.margin[2];
  1749.     var yOffset = this.posY + this.ctx.prevPageLastElemOffset;
  1751.     switch (path.type) {
  1752.       default:
  1753.       case "mt":
  1754.       case "lt":
  1755.         result.push(Math.floor((path.y + yOffset) / pageWrapY) + 1);
  1756.         break;
  1757.       case "arc":
  1758.         result.push(
  1759.           Math.floor((path.y + yOffset - path.radius) / pageWrapY) + 1
  1760.         );
  1761.         result.push(
  1762.           Math.floor((path.y + yOffset + path.radius) / pageWrapY) + 1
  1763.         );
  1764.         break;
  1765.       case "qct":
  1766.         var rectOfQuadraticCurve = getQuadraticCurveBoundary(
  1767.           this.ctx.lastPoint.x,
  1768.           this.ctx.lastPoint.y,
  1769.           path.x1,
  1770.           path.y1,
  1771.           path.x,
  1772.           path.y
  1773.         );
  1774.         result.push(
  1775.           Math.floor((rectOfQuadraticCurve.y + yOffset) / pageWrapY) + 1
  1776.         );
  1777.         result.push(
  1778.           Math.floor(
  1779.             (rectOfQuadraticCurve.y + rectOfQuadraticCurve.h + yOffset) /
  1780.               pageWrapY
  1781.           ) + 1
  1782.         );
  1783.         break;
  1784.       case "bct":
  1785.         var rectOfBezierCurve = getBezierCurveBoundary(
  1786.           this.ctx.lastPoint.x,
  1787.           this.ctx.lastPoint.y,
  1788.           path.x1,
  1789.           path.y1,
  1790.           path.x2,
  1791.           path.y2,
  1792.           path.x,
  1793.           path.y
  1794.         );
  1795.         result.push(
  1796.           Math.floor((rectOfBezierCurve.y + yOffset) / pageWrapY) + 1
  1797.         );
  1798.         result.push(
  1799.           Math.floor(
  1800.             (rectOfBezierCurve.y + rectOfBezierCurve.h + yOffset) / pageWrapY
  1801.           ) + 1
  1802.         );
  1803.         break;
  1804.       case "rect":
  1805.         result.push(Math.floor((path.y + yOffset) / pageWrapY) + 1);
  1806.         result.push(Math.floor((path.y + path.h + yOffset) / pageWrapY) + 1);
  1807.     }
  1809.     for (var i = 0; i < result.length; i += 1) {
  1810.       while (this.pdf.internal.getNumberOfPages() < result[i]) {
  1811.         addPage.call(this);
  1812.       }
  1813.     }
  1814.     return result;
  1815.   };
  1817.   var addPage = function() {
  1818.     var fillStyle = this.fillStyle;
  1819.     var strokeStyle = this.strokeStyle;
  1820.     var font = this.font;
  1821.     var lineCap = this.lineCap;
  1822.     var lineWidth = this.lineWidth;
  1823.     var lineJoin = this.lineJoin;
  1824.     this.pdf.addPage();
  1825.     this.fillStyle = fillStyle;
  1826.     this.strokeStyle = strokeStyle;
  1827.     this.font = font;
  1828.     this.lineCap = lineCap;
  1829.     this.lineWidth = lineWidth;
  1830.     this.lineJoin = lineJoin;
  1831.   };
  1833.   var pathPositionRedo = function(paths, x, y) {
  1834.     for (var i = 0; i < paths.length; i++) {
  1835.       switch (paths[i].type) {
  1836.         case "bct":
  1837.           paths[i].x2 += x;
  1838.           paths[i].y2 += y;
  1839.         case "qct":
  1840.           paths[i].x1 += x;
  1841.           paths[i].y1 += y;
  1842.         case "mt":
  1843.         case "lt":
  1844.         case "arc":
  1845.         default:
  1846.           paths[i].x += x;
  1847.           paths[i].y += y;
  1848.       }
  1849.     }
  1850.     return paths;
  1851.   };
  1853.   var sortPages = function(pages) {
  1854.     return pages.sort(function(a, b) {
  1855.       return a - b;
  1856.     });
  1857.   };
  1859.   var pathPreProcess = function(rule, isClip) {
  1860.     var fillStyle = this.fillStyle;
  1861.     var strokeStyle = this.strokeStyle;
  1862.     var lineCap = this.lineCap;
  1863.     var oldLineWidth = this.lineWidth;
  1864.     var lineWidth = Math.abs(oldLineWidth * this.ctx.transform.scaleX);
  1865.     var lineJoin = this.lineJoin;
  1867.     var origPath = JSON.parse(JSON.stringify(this.path));
  1868.     var xPath = JSON.parse(JSON.stringify(this.path));
  1869.     var clipPath;
  1870.     var tmpPath;
  1871.     var pages = [];
  1873.     for (var i = 0; i < xPath.length; i++) {
  1874.       if (typeof xPath[i].x !== "undefined") {
  1875.         var page = getPagesByPath.call(this, xPath[i]);
  1877.         for (var ii = 0; ii < page.length; ii += 1) {
  1878.           if (pages.indexOf(page[ii]) === -1) {
  1879.             pages.push(page[ii]);
  1880.           }
  1881.         }
  1882.       }
  1883.     }
  1885.     for (var j = 0; j < pages.length; j++) {
  1886.       while (this.pdf.internal.getNumberOfPages() < pages[j]) {
  1887.         addPage.call(this);
  1888.       }
  1889.     }
  1890.     sortPages(pages);
  1892.     if (this.autoPaging) {
  1893.       var min = pages[0];
  1894.       var max = pages[pages.length - 1];
  1895.       for (var k = min; k < max + 1; k++) {
  1896.         this.pdf.setPage(k);
  1898.         this.fillStyle = fillStyle;
  1899.         this.strokeStyle = strokeStyle;
  1900.         this.lineCap = lineCap;
  1901.         this.lineWidth = lineWidth;
  1902.         this.lineJoin = lineJoin;
  1904.         var pageWidthMinusMargins =
  1905.           this.pdf.internal.pageSize.width - this.margin[3] - this.margin[1];
  1906.         var topMargin = k === 1 ? this.posY + this.margin[0] : this.margin[0];
  1907.         var firstPageHeight =
  1908.           this.pdf.internal.pageSize.height -
  1909.           this.posY -
  1910.           this.margin[0] -
  1911.           this.margin[2];
  1912.         var pageHeightMinusMargins =
  1913.           this.pdf.internal.pageSize.height - this.margin[0] - this.margin[2];
  1914.         var previousPageHeightSum =
  1915.           k === 1 ? 0 : firstPageHeight + (k - 2) * pageHeightMinusMargins;
  1917.         if (this.ctx.clip_path.length !== 0) {
  1918.           var tmpPaths = this.path;
  1919.           clipPath = JSON.parse(JSON.stringify(this.ctx.clip_path));
  1920.           this.path = pathPositionRedo(
  1921.             clipPath,
  1922.             this.posX + this.margin[3],
  1923.             -previousPageHeightSum + topMargin + this.ctx.prevPageLastElemOffset
  1924.           );
  1925.           drawPaths.call(this, rule, true);
  1926.           this.path = tmpPaths;
  1927.         }
  1928.         tmpPath = JSON.parse(JSON.stringify(origPath));
  1929.         this.path = pathPositionRedo(
  1930.           tmpPath,
  1931.           this.posX + this.margin[3],
  1932.           -previousPageHeightSum + topMargin + this.ctx.prevPageLastElemOffset
  1933.         );
  1934.         if (isClip === false || k === 0) {
  1935.           const needsClipping = (k > min || k < max) && hasMargins.call(this);
  1936.           if (needsClipping) {
  1937.             this.pdf.saveGraphicsState();
  1938.             this.pdf
  1939.               .rect(
  1940.                 this.margin[3],
  1941.                 this.margin[0],
  1942.                 pageWidthMinusMargins,
  1943.                 pageHeightMinusMargins,
  1944.                 null
  1945.               )
  1946.               .clip()
  1947.               .discardPath();
  1948.           }
  1949.           drawPaths.call(this, rule, isClip);
  1950.           if (needsClipping) {
  1951.             this.pdf.restoreGraphicsState();
  1952.           }
  1953.         }
  1954.         this.lineWidth = oldLineWidth;
  1955.       }
  1956.     } else {
  1957.       this.lineWidth = lineWidth;
  1958.       drawPaths.call(this, rule, isClip);
  1959.       this.lineWidth = oldLineWidth;
  1960.     }
  1961.     this.path = origPath;
  1962.   };
  1964.   /**
  1965.    * Processes the paths
  1966.    *
  1967.    * @function
  1968.    * @param rule {String}
  1969.    * @param isClip {Boolean}
  1970.    * @private
  1971.    * @ignore
  1972.    */
  1973.   var drawPaths = function(rule, isClip) {
  1974.     if (rule === "stroke" && !isClip && isStrokeTransparent.call(this)) {
  1975.       return;
  1976.     }
  1978.     if (rule !== "stroke" && !isClip && isFillTransparent.call(this)) {
  1979.       return;
  1980.     }
  1982.     var moves = [];
  1984.     //var alpha = (this.ctx.fillOpacity < 1) ? this.ctx.fillOpacity : this.ctx.globalAlpha;
  1985.     var delta;
  1986.     var xPath = this.path;
  1987.     for (var i = 0; i < xPath.length; i++) {
  1988.       var pt = xPath[i];
  1990.       switch (pt.type) {
  1991.         case "begin":
  1992.           moves.push({
  1993.             begin: true
  1994.           });
  1995.           break;
  1997.         case "close":
  1998.           moves.push({
  1999.             close: true
  2000.           });
  2001.           break;
  2003.         case "mt":
  2004.           moves.push({
  2005.             start: pt,
  2006.             deltas: [],
  2007.             abs: []
  2008.           });
  2009.           break;
  2011.         case "lt":
  2012.           var iii = moves.length;
  2013.           if (xPath[i - 1] && !isNaN(xPath[i - 1].x)) {
  2014.             delta = [pt.x - xPath[i - 1].x, pt.y - xPath[i - 1].y];
  2015.             if (iii > 0) {
  2016.               for (iii; iii >= 0; iii--) {
  2017.                 if (
  2018.                   moves[iii - 1].close !== true &&
  2019.                   moves[iii - 1].begin !== true
  2020.                 ) {
  2021.                   moves[iii - 1].deltas.push(delta);
  2022.                   moves[iii - 1].abs.push(pt);
  2023.                   break;
  2024.                 }
  2025.               }
  2026.             }
  2027.           }
  2028.           break;
  2030.         case "bct":
  2031.           delta = [
  2032.             pt.x1 - xPath[i - 1].x,
  2033.             pt.y1 - xPath[i - 1].y,
  2034.             pt.x2 - xPath[i - 1].x,
  2035.             pt.y2 - xPath[i - 1].y,
  2036.             pt.x - xPath[i - 1].x,
  2037.             pt.y - xPath[i - 1].y
  2038.           ];
  2039.           moves[moves.length - 1].deltas.push(delta);
  2040.           break;
  2042.         case "qct":
  2043.           var x1 = xPath[i - 1].x + (2.0 / 3.0) * (pt.x1 - xPath[i - 1].x);
  2044.           var y1 = xPath[i - 1].y + (2.0 / 3.0) * (pt.y1 - xPath[i - 1].y);
  2045.           var x2 = pt.x + (2.0 / 3.0) * (pt.x1 - pt.x);
  2046.           var y2 = pt.y + (2.0 / 3.0) * (pt.y1 - pt.y);
  2047.           var x3 = pt.x;
  2048.           var y3 = pt.y;
  2049.           delta = [
  2050.             x1 - xPath[i - 1].x,
  2051.             y1 - xPath[i - 1].y,
  2052.             x2 - xPath[i - 1].x,
  2053.             y2 - xPath[i - 1].y,
  2054.             x3 - xPath[i - 1].x,
  2055.             y3 - xPath[i - 1].y
  2056.           ];
  2057.           moves[moves.length - 1].deltas.push(delta);
  2058.           break;
  2060.         case "arc":
  2061.           moves.push({
  2062.             deltas: [],
  2063.             abs: [],
  2064.             arc: true
  2065.           });
  2067.           if (Array.isArray(moves[moves.length - 1].abs)) {
  2068.             moves[moves.length - 1].abs.push(pt);
  2069.           }
  2070.           break;
  2071.       }
  2072.     }
  2073.     var style;
  2074.     if (!isClip) {
  2075.       if (rule === "stroke") {
  2076.         style = "stroke";
  2077.       } else {
  2078.         style = "fill";
  2079.       }
  2080.     } else {
  2081.       style = null;
  2082.     }
  2084.     var began = false;
  2085.     for (var k = 0; k < moves.length; k++) {
  2086.       if (moves[k].arc) {
  2087.         var arcs = moves[k].abs;
  2089.         for (var ii = 0; ii < arcs.length; ii++) {
  2090.           var arc = arcs[ii];
  2092.           if (arc.type === "arc") {
  2093.             drawArc.call(
  2094.               this,
  2095.               arc.x,
  2096.               arc.y,
  2097.               arc.radius,
  2098.               arc.startAngle,
  2099.               arc.endAngle,
  2100.               arc.counterclockwise,
  2101.               undefined,
  2102.               isClip,
  2103.               !began
  2104.             );
  2105.           } else {
  2106.             drawLine.call(this, arc.x, arc.y);
  2107.           }
  2108.           began = true;
  2109.         }
  2110.       } else if (moves[k].close === true) {
  2111.         this.pdf.internal.out("h");
  2112.         began = false;
  2113.       } else if (moves[k].begin !== true) {
  2114.         var x = moves[k].start.x;
  2115.         var y = moves[k].start.y;
  2116.         drawLines.call(this, moves[k].deltas, x, y);
  2117.         began = true;
  2118.       }
  2119.     }
  2121.     if (style) {
  2122.       putStyle.call(this, style);
  2123.     }
  2124.     if (isClip) {
  2125.       doClip.call(this);
  2126.     }
  2127.   };
  2129.   var getBaseline = function(y) {
  2130.     var height =
  2131.       this.pdf.internal.getFontSize() / this.pdf.internal.scaleFactor;
  2132.     var descent = height * (this.pdf.internal.getLineHeightFactor() - 1);
  2133.     switch (this.ctx.textBaseline) {
  2134.       case "bottom":
  2135.         return y - descent;
  2136.       case "top":
  2137.         return y + height - descent;
  2138.       case "hanging":
  2139.         return y + height - 2 * descent;
  2140.       case "middle":
  2141.         return y + height / 2 - descent;
  2142.       case "ideographic":
  2143.         // TODO not implemented
  2144.         return y;
  2145.       case "alphabetic":
  2146.       default:
  2147.         return y;
  2148.     }
  2149.   };
  2151.   var getTextBottom = function(yBaseLine) {
  2152.     var height =
  2153.       this.pdf.internal.getFontSize() / this.pdf.internal.scaleFactor;
  2154.     var descent = height * (this.pdf.internal.getLineHeightFactor() - 1);
  2155.     return yBaseLine + descent;
  2156.   };
  2158.   Context2D.prototype.createLinearGradient = function createLinearGradient() {
  2159.     var canvasGradient = function canvasGradient() {};
  2161.     canvasGradient.colorStops = [];
  2162.     canvasGradient.addColorStop = function(offset, color) {
  2163.       this.colorStops.push([offset, color]);
  2164.     };
  2166.     canvasGradient.getColor = function() {
  2167.       if (this.colorStops.length === 0) {
  2168.         return "#000000";
  2169.       }
  2171.       return this.colorStops[0][1];
  2172.     };
  2174.     canvasGradient.isCanvasGradient = true;
  2175.     return canvasGradient;
  2176.   };
  2177.   Context2D.prototype.createPattern = function createPattern() {
  2178.     return this.createLinearGradient();
  2179.   };
  2180.   Context2D.prototype.createRadialGradient = function createRadialGradient() {
  2181.     return this.createLinearGradient();
  2182.   };
  2184.   /**
  2185.    *
  2186.    * @param x Edge point X
  2187.    * @param y Edge point Y
  2188.    * @param r Radius
  2189.    * @param a1 start angle
  2190.    * @param a2 end angle
  2191.    * @param counterclockwise
  2192.    * @param style
  2193.    * @param isClip
  2194.    */
  2195.   var drawArc = function(
  2196.     x,
  2197.     y,
  2198.     r,
  2199.     a1,
  2200.     a2,
  2201.     counterclockwise,
  2202.     style,
  2203.     isClip,
  2204.     includeMove
  2205.   ) {
  2206.     // http://hansmuller-flex.blogspot.com/2011/10/more-about-approximating-circular-arcs.html
  2207.     var curves = createArc.call(this, r, a1, a2, counterclockwise);
  2209.     for (var i = 0; i < curves.length; i++) {
  2210.       var curve = curves[i];
  2211.       if (i === 0) {
  2212.         if (includeMove) {
  2213.           doMove.call(this, curve.x1 + x, curve.y1 + y);
  2214.         } else {
  2215.           drawLine.call(this, curve.x1 + x, curve.y1 + y);
  2216.         }
  2217.       }
  2218.       drawCurve.call(
  2219.         this,
  2220.         x,
  2221.         y,
  2222.         curve.x2,
  2223.         curve.y2,
  2224.         curve.x3,
  2225.         curve.y3,
  2226.         curve.x4,
  2227.         curve.y4
  2228.       );
  2229.     }
  2231.     if (!isClip) {
  2232.       putStyle.call(this, style);
  2233.     } else {
  2234.       doClip.call(this);
  2235.     }
  2236.   };
  2238.   var putStyle = function(style) {
  2239.     switch (style) {
  2240.       case "stroke":
  2241.         this.pdf.internal.out("S");
  2242.         break;
  2243.       case "fill":
  2244.         this.pdf.internal.out("f");
  2245.         break;
  2246.     }
  2247.   };
  2249.   var doClip = function() {
  2250.     this.pdf.clip();
  2251.     this.pdf.discardPath();
  2252.   };
  2254.   var doMove = function(x, y) {
  2255.     this.pdf.internal.out(
  2256.       getHorizontalCoordinateString(x) +
  2257.         " " +
  2258.         getVerticalCoordinateString(y) +
  2259.         " m"
  2260.     );
  2261.   };
  2263.   var putText = function(options) {
  2264.     var textAlign;
  2265.     switch (options.align) {
  2266.       case "right":
  2267.       case "end":
  2268.         textAlign = "right";
  2269.         break;
  2270.       case "center":
  2271.         textAlign = "center";
  2272.         break;
  2273.       case "left":
  2274.       case "start":
  2275.       default:
  2276.         textAlign = "left";
  2277.         break;
  2278.     }
  2280.     var textDimensions = this.pdf.getTextDimensions(options.text);
  2281.     var yBaseLine = getBaseline.call(this, options.y);
  2282.     var yBottom = getTextBottom.call(this, yBaseLine);
  2283.     var yTop = yBottom - textDimensions.h;
  2285.     var pt = this.ctx.transform.applyToPoint(new Point(options.x, yBaseLine));
  2286.     var decomposedTransformationMatrix = this.ctx.transform.decompose();
  2287.     var matrix = new Matrix();
  2288.     matrix = matrix.multiply(decomposedTransformationMatrix.translate);
  2289.     matrix = matrix.multiply(decomposedTransformationMatrix.skew);
  2290.     matrix = matrix.multiply(decomposedTransformationMatrix.scale);
  2292.     var baselineRect = this.ctx.transform.applyToRectangle(
  2293.       new Rectangle(options.x, yBaseLine, textDimensions.w, textDimensions.h)
  2294.     );
  2295.     var textBounds = matrix.applyToRectangle(
  2296.       new Rectangle(options.x, yTop, textDimensions.w, textDimensions.h)
  2297.     );
  2298.     var pageArray = getPagesByPath.call(this, textBounds);
  2299.     var pages = [];
  2300.     for (var ii = 0; ii < pageArray.length; ii += 1) {
  2301.       if (pages.indexOf(pageArray[ii]) === -1) {
  2302.         pages.push(pageArray[ii]);
  2303.       }
  2304.     }
  2306.     sortPages(pages);
  2308.     var clipPath, oldSize, oldLineWidth;
  2309.     if (this.autoPaging) {
  2310.       var min = pages[0];
  2311.       var max = pages[pages.length - 1];
  2312.       for (var i = min; i < max + 1; i++) {
  2313.         this.pdf.setPage(i);
  2315.         var topMargin = i === 1 ? this.posY + this.margin[0] : this.margin[0];
  2316.         var firstPageHeight =
  2317.           this.pdf.internal.pageSize.height -
  2318.           this.posY -
  2319.           this.margin[0] -
  2320.           this.margin[2];
  2321.         var pageHeightMinusBottomMargin =
  2322.           this.pdf.internal.pageSize.height - this.margin[2];
  2323.         var pageHeightMinusMargins =
  2324.           pageHeightMinusBottomMargin - this.margin[0];
  2325.         var pageWidthMinusRightMargin =
  2326.           this.pdf.internal.pageSize.width - this.margin[1];
  2327.         var pageWidthMinusMargins = pageWidthMinusRightMargin - this.margin[3];
  2328.         var previousPageHeightSum =
  2329.           i === 1 ? 0 : firstPageHeight + (i - 2) * pageHeightMinusMargins;
  2331.         if (this.ctx.clip_path.length !== 0) {
  2332.           var tmpPaths = this.path;
  2333.           clipPath = JSON.parse(JSON.stringify(this.ctx.clip_path));
  2334.           this.path = pathPositionRedo(
  2335.             clipPath,
  2336.             this.posX + this.margin[3],
  2337.             -1 * previousPageHeightSum + topMargin
  2338.           );
  2339.           drawPaths.call(this, "fill", true);
  2340.           this.path = tmpPaths;
  2341.         }
  2342.         var textBoundsOnPage = pathPositionRedo(
  2343.           [JSON.parse(JSON.stringify(textBounds))],
  2344.           this.posX + this.margin[3],
  2345.           -previousPageHeightSum + topMargin + this.ctx.prevPageLastElemOffset
  2346.         )[0];
  2348.         if (options.scale >= 0.01) {
  2349.           oldSize = this.pdf.internal.getFontSize();
  2350.           this.pdf.setFontSize(oldSize * options.scale);
  2351.           oldLineWidth = this.lineWidth;
  2352.           this.lineWidth = oldLineWidth * options.scale;
  2353.         }
  2355.         var doSlice = this.autoPaging !== "text";
  2357.         if (
  2358.           doSlice ||
  2359.           textBoundsOnPage.y + textBoundsOnPage.h <= pageHeightMinusBottomMargin
  2360.         ) {
  2361.           if (
  2362.             doSlice ||
  2363.             (textBoundsOnPage.y >= topMargin &&
  2364.               textBoundsOnPage.x <= pageWidthMinusRightMargin)
  2365.           ) {
  2366.             var croppedText = doSlice
  2367.               ? options.text
  2368.               : this.pdf.splitTextToSize(
  2369.                   options.text,
  2370.                   options.maxWidth ||
  2371.                     pageWidthMinusRightMargin - textBoundsOnPage.x
  2372.                 )[0];
  2373.             var baseLineRectOnPage = pathPositionRedo(
  2374.               [JSON.parse(JSON.stringify(baselineRect))],
  2375.               this.posX + this.margin[3],
  2376.               -previousPageHeightSum +
  2377.                 topMargin +
  2378.                 this.ctx.prevPageLastElemOffset
  2379.             )[0];
  2381.             const needsClipping =
  2382.               doSlice && (i > min || i < max) && hasMargins.call(this);
  2384.             if (needsClipping) {
  2385.               this.pdf.saveGraphicsState();
  2386.               this.pdf
  2387.                 .rect(
  2388.                   this.margin[3],
  2389.                   this.margin[0],
  2390.                   pageWidthMinusMargins,
  2391.                   pageHeightMinusMargins,
  2392.                   null
  2393.                 )
  2394.                 .clip()
  2395.                 .discardPath();
  2396.             }
  2398.             this.pdf.text(
  2399.               croppedText,
  2400.               baseLineRectOnPage.x,
  2401.               baseLineRectOnPage.y,
  2402.               {
  2403.                 angle: options.angle,
  2404.                 align: textAlign,
  2405.                 renderingMode: options.renderingMode
  2406.               }
  2407.             );
  2409.             if (needsClipping) {
  2410.               this.pdf.restoreGraphicsState();
  2411.             }
  2412.           }
  2413.         } else {
  2414.           // This text is the last element of the page, but it got cut off due to the margin
  2415.           // so we render it in the next page
  2417.           if (textBoundsOnPage.y < pageHeightMinusBottomMargin) {
  2418.             // As a result, all other elements have their y offset increased
  2419.             this.ctx.prevPageLastElemOffset +=
  2420.               pageHeightMinusBottomMargin - textBoundsOnPage.y;
  2421.           }
  2422.         }
  2424.         if (options.scale >= 0.01) {
  2425.           this.pdf.setFontSize(oldSize);
  2426.           this.lineWidth = oldLineWidth;
  2427.         }
  2428.       }
  2429.     } else {
  2430.       if (options.scale >= 0.01) {
  2431.         oldSize = this.pdf.internal.getFontSize();
  2432.         this.pdf.setFontSize(oldSize * options.scale);
  2433.         oldLineWidth = this.lineWidth;
  2434.         this.lineWidth = oldLineWidth * options.scale;
  2435.       }
  2436.       this.pdf.text(options.text, pt.x + this.posX, pt.y + this.posY, {
  2437.         angle: options.angle,
  2438.         align: textAlign,
  2439.         renderingMode: options.renderingMode,
  2440.         maxWidth: options.maxWidth
  2441.       });
  2443.       if (options.scale >= 0.01) {
  2444.         this.pdf.setFontSize(oldSize);
  2445.         this.lineWidth = oldLineWidth;
  2446.       }
  2447.     }
  2448.   };
  2450.   var drawLine = function(x, y, prevX, prevY) {
  2451.     prevX = prevX || 0;
  2452.     prevY = prevY || 0;
  2454.     this.pdf.internal.out(
  2455.       getHorizontalCoordinateString(x + prevX) +
  2456.         " " +
  2457.         getVerticalCoordinateString(y + prevY) +
  2458.         " l"
  2459.     );
  2460.   };
  2462.   var drawLines = function(lines, x, y) {
  2463.     return this.pdf.lines(lines, x, y, null, null);
  2464.   };
  2466.   var drawCurve = function(x, y, x1, y1, x2, y2, x3, y3) {
  2467.     this.pdf.internal.out(
  2468.       [
  2469.         f2(getHorizontalCoordinate(x1 + x)),
  2470.         f2(getVerticalCoordinate(y1 + y)),
  2471.         f2(getHorizontalCoordinate(x2 + x)),
  2472.         f2(getVerticalCoordinate(y2 + y)),
  2473.         f2(getHorizontalCoordinate(x3 + x)),
  2474.         f2(getVerticalCoordinate(y3 + y)),
  2475.         "c"
  2476.       ].join(" ")
  2477.     );
  2478.   };
  2480.   /**
  2481.    * Return a array of objects that represent bezier curves which approximate the circular arc centered at the origin, from startAngle to endAngle (radians) with the specified radius.
  2482.    *
  2483.    * Each bezier curve is an object with four points, where x1,y1 and x4,y4 are the arc's end points and x2,y2 and x3,y3 are the cubic bezier's control points.
  2484.    * @function createArc
  2485.    */
  2486.   var createArc = function(radius, startAngle, endAngle, anticlockwise) {
  2487.     var EPSILON = 0.00001; // Roughly 1/1000th of a degree, see below
  2488.     var twoPi = Math.PI * 2;
  2489.     var halfPi = Math.PI / 2.0;
  2491.     while (startAngle > endAngle) {
  2492.       startAngle = startAngle - twoPi;
  2493.     }
  2494.     var totalAngle = Math.abs(endAngle - startAngle);
  2495.     if (totalAngle < twoPi) {
  2496.       if (anticlockwise) {
  2497.         totalAngle = twoPi - totalAngle;
  2498.       }
  2499.     }
  2501.     // Compute the sequence of arc curves, up to PI/2 at a time.
  2502.     var curves = [];
  2504.     // clockwise or counterclockwise
  2505.     var sgn = anticlockwise ? -1 : +1;
  2507.     var a1 = startAngle;
  2508.     for (; totalAngle > EPSILON; ) {
  2509.       var remain = sgn * Math.min(totalAngle, halfPi);
  2510.       var a2 = a1 + remain;
  2511.       curves.push(createSmallArc.call(this, radius, a1, a2));
  2512.       totalAngle -= Math.abs(a2 - a1);
  2513.       a1 = a2;
  2514.     }
  2516.     return curves;
  2517.   };
  2519.   /**
  2520.    * Cubic bezier approximation of a circular arc centered at the origin, from (radians) a1 to a2, where a2-a1 < pi/2. The arc's radius is r.
  2521.    *
  2522.    * Returns an object with four points, where x1,y1 and x4,y4 are the arc's end points and x2,y2 and x3,y3 are the cubic bezier's control points.
  2523.    *
  2524.    * This algorithm is based on the approach described in: A. Riškus, "Approximation of a Cubic Bezier Curve by Circular Arcs and Vice Versa," Information Technology and Control, 35(4), 2006 pp. 371-378.
  2525.    */
  2526.   var createSmallArc = function(r, a1, a2) {
  2527.     var a = (a2 - a1) / 2.0;
  2529.     var x4 = r * Math.cos(a);
  2530.     var y4 = r * Math.sin(a);
  2531.     var x1 = x4;
  2532.     var y1 = -y4;
  2534.     var q1 = x1 * x1 + y1 * y1;
  2535.     var q2 = q1 + x1 * x4 + y1 * y4;
  2536.     var k2 = ((4 / 3) * (Math.sqrt(2 * q1 * q2) - q2)) / (x1 * y4 - y1 * x4);
  2538.     var x2 = x1 - k2 * y1;
  2539.     var y2 = y1 + k2 * x1;
  2540.     var x3 = x2;
  2541.     var y3 = -y2;
  2543.     var ar = a + a1;
  2544.     var cos_ar = Math.cos(ar);
  2545.     var sin_ar = Math.sin(ar);
  2547.     return {
  2548.       x1: r * Math.cos(a1),
  2549.       y1: r * Math.sin(a1),
  2550.       x2: x2 * cos_ar - y2 * sin_ar,
  2551.       y2: x2 * sin_ar + y2 * cos_ar,
  2552.       x3: x3 * cos_ar - y3 * sin_ar,
  2553.       y3: x3 * sin_ar + y3 * cos_ar,
  2554.       x4: r * Math.cos(a2),
  2555.       y4: r * Math.sin(a2)
  2556.     };
  2557.   };
  2559.   var rad2deg = function(value) {
  2560.     return (value * 180) / Math.PI;
  2561.   };
  2563.   var getQuadraticCurveBoundary = function(sx, sy, cpx, cpy, ex, ey) {
  2564.     var midX1 = sx + (cpx - sx) * 0.5;
  2565.     var midY1 = sy + (cpy - sy) * 0.5;
  2566.     var midX2 = ex + (cpx - ex) * 0.5;
  2567.     var midY2 = ey + (cpy - ey) * 0.5;
  2568.     var resultX1 = Math.min(sx, ex, midX1, midX2);
  2569.     var resultX2 = Math.max(sx, ex, midX1, midX2);
  2570.     var resultY1 = Math.min(sy, ey, midY1, midY2);
  2571.     var resultY2 = Math.max(sy, ey, midY1, midY2);
  2572.     return new Rectangle(
  2573.       resultX1,
  2574.       resultY1,
  2575.       resultX2 - resultX1,
  2576.       resultY2 - resultY1
  2577.     );
  2578.   };
  2580.   //De Casteljau algorithm
  2581.   var getBezierCurveBoundary = function(ax, ay, bx, by, cx, cy, dx, dy) {
  2582.     var tobx = bx - ax;
  2583.     var toby = by - ay;
  2584.     var tocx = cx - bx;
  2585.     var tocy = cy - by;
  2586.     var todx = dx - cx;
  2587.     var tody = dy - cy;
  2588.     var precision = 40;
  2589.     var d,
  2590.       i,
  2591.       px,
  2592.       py,
  2593.       qx,
  2594.       qy,
  2595.       rx,
  2596.       ry,
  2597.       tx,
  2598.       ty,
  2599.       sx,
  2600.       sy,
  2601.       x,
  2602.       y,
  2603.       minx,
  2604.       miny,
  2605.       maxx,
  2606.       maxy,
  2607.       toqx,
  2608.       toqy,
  2609.       torx,
  2610.       tory,
  2611.       totx,
  2612.       toty;
  2613.     for (i = 0; i < precision + 1; i++) {
  2614.       d = i / precision;
  2615.       px = ax + d * tobx;
  2616.       py = ay + d * toby;
  2617.       qx = bx + d * tocx;
  2618.       qy = by + d * tocy;
  2619.       rx = cx + d * todx;
  2620.       ry = cy + d * tody;
  2621.       toqx = qx - px;
  2622.       toqy = qy - py;
  2623.       torx = rx - qx;
  2624.       tory = ry - qy;
  2626.       sx = px + d * toqx;
  2627.       sy = py + d * toqy;
  2628.       tx = qx + d * torx;
  2629.       ty = qy + d * tory;
  2630.       totx = tx - sx;
  2631.       toty = ty - sy;
  2633.       x = sx + d * totx;
  2634.       y = sy + d * toty;
  2635.       if (i == 0) {
  2636.         minx = x;
  2637.         miny = y;
  2638.         maxx = x;
  2639.         maxy = y;
  2640.       } else {
  2641.         minx = Math.min(minx, x);
  2642.         miny = Math.min(miny, y);
  2643.         maxx = Math.max(maxx, x);
  2644.         maxy = Math.max(maxy, y);
  2645.       }
  2646.     }
  2647.     return new Rectangle(
  2648.       Math.round(minx),
  2649.       Math.round(miny),
  2650.       Math.round(maxx - minx),
  2651.       Math.round(maxy - miny)
  2652.     );
  2653.   };
  2655.   var getPrevLineDashValue = function(lineDash, lineDashOffset) {
  2656.     return JSON.stringify({
  2657.       lineDash: lineDash,
  2658.       lineDashOffset: lineDashOffset
  2659.     });
  2660.   };
  2662.   var setLineDash = function() {
  2663.     // Avoid unnecessary line dash declarations.
  2664.     if (
  2665.       !this.prevLineDash &&
  2666.       !this.ctx.lineDash.length &&
  2667.       !this.ctx.lineDashOffset
  2668.     ) {
  2669.       return;
  2670.     }
  2672.     // Avoid unnecessary line dash declarations.
  2673.     const nextLineDash = getPrevLineDashValue(
  2674.       this.ctx.lineDash,
  2675.       this.ctx.lineDashOffset
  2676.     );
  2677.     if (this.prevLineDash !== nextLineDash) {
  2678.       this.pdf.setLineDash(this.ctx.lineDash, this.ctx.lineDashOffset);
  2679.       this.prevLineDash = nextLineDash;
  2680.     }
  2681.   };
  2682. })(jsPDF.API);