/jspdf.plugin.from_html.js

https://github.com/HangYang/jsPDF · JavaScript · 536 lines · 490 code · 1 blank · 45 comment · 108 complexity · 4db4ace45ad9002b99c02f9989fc35db MD5 · raw file 

    

  1. /** @preserve
    2. 

  2.  * jsPDF fromHTML plugin. BETA stage. API subject to change. Needs browser
    3. 

  3.  * Copyright (c) 2012 Willow Systems Corporation, willow-systems.com
    4. 

  4.  *               2014 Juan Pablo Gaviria, https://github.com/juanpgaviria
    5. 

  5.  *               2014 Diego Casorran, https://github.com/diegocr
    6. 

  6.  *
    7. 

  7.  * Permission is hereby granted, free of charge, to any person obtaining
    8. 

  8.  * a copy of this software and associated documentation files (the
    9. 

  9.  * "Software"), to deal in the Software without restriction, including
    10. 

  10.  * without limitation the rights to use, copy, modify, merge, publish,
    11. 

  11.  * distribute, sublicense, and/or sell copies of the Software, and to
    12. 

  12.  * permit persons to whom the Software is furnished to do so, subject to
    13. 

  13.  * the following conditions:
    14. 

  14.  *
    15. 

  15.  * The above copyright notice and this permission notice shall be
    16. 

  16.  * included in all copies or substantial portions of the Software.
    17. 

  17.  *
    18. 

  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    19. 

  19.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    20. 

  20.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
    21. 

  21.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
    22. 

  22.  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
    23. 

  23.  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
    24. 

  24.  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    25. 

  25.  * ====================================================================
    26. 

  26.  */
    27. 

  27. 

  28. (function(jsPDFAPI) {
    29. 

  29.   var DrillForContent, FontNameDB, FontStyleMap, FontWeightMap, GetCSS, PurgeWhiteSpace, Renderer, ResolveFont, ResolveUnitedNumber, UnitedNumberMap, elementHandledElsewhere, images, loadImgs, process, tableToJson;
    30. 

  30.   PurgeWhiteSpace = function(array) {
    31. 

  31.     var fragment, i, l, lTrimmed, r, rTrimmed, trailingSpace;
    32. 

  32.     i = 0;
    33. 

  33.     l = array.length;
    34. 

  34.     fragment = void 0;
    35. 

  35.     lTrimmed = false;
    36. 

  36.     rTrimmed = false;
    37. 

  37.     while (!lTrimmed && i !== l) {
    38. 

  38.       fragment = array[i] = array[i].trimLeft();
    39. 

  39.       if (fragment) {
    40. 

  40.         lTrimmed = true;
    41. 

  41.       }
    42. 

  42.       i++;
    43. 

  43.     }
    44. 

  44.     i = l - 1;
    45. 

  45.     while (l && !rTrimmed && i !== -1) {
    46. 

  46.       fragment = array[i] = array[i].trimRight();
    47. 

  47.       if (fragment) {
    48. 

  48.         rTrimmed = true;
    49. 

  49.       }
    50. 

  50.       i--;
    51. 

  51.     }
    52. 

  52.     r = /\s+$/g;
    53. 

  53.     trailingSpace = true;
    54. 

  54.     i = 0;
    55. 

  55.     while (i !== l) {
    56. 

  56.       fragment = array[i].replace(/\s+/g, " ");
    57. 

  57.       if (trailingSpace) {
    58. 

  58.         fragment = fragment.trimLeft();
    59. 

  59.       }
    60. 

  60.       if (fragment) {
    61. 

  61.         trailingSpace = r.test(fragment);
    62. 

  62.       }
    63. 

  63.       array[i] = fragment;
    64. 

  64.       i++;
    65. 

  65.     }
    66. 

  66.     return array;
    67. 

  67.   };
    68. 

  68.   Renderer = function(pdf, x, y, settings) {
    69. 

  69.     this.pdf = pdf;
    70. 

  70.     this.x = x;
    71. 

  71.     this.y = y;
    72. 

  72.     this.settings = settings;
    73. 

  73.     this.init();
    74. 

  74.     return this;
    75. 

  75.   };
    76. 

  76.   ResolveFont = function(css_font_family_string) {
    77. 

  77.     var name, part, parts;
    78. 

  78.     name = void 0;
    79. 

  79.     parts = css_font_family_string.split(",");
    80. 

  80.     part = parts.shift();
    81. 

  81.     while (!name && part) {
    82. 

  82.       name = FontNameDB[part.trim().toLowerCase()];
    83. 

  83.       part = parts.shift();
    84. 

  84.     }
    85. 

  85.     return name;
    86. 

  86.   };
    87. 

  87.   ResolveUnitedNumber = function(css_line_height_string) {
    88. 

  88.     var normal, undef, value;
    89. 

  89.     undef = void 0;
    90. 

  90.     normal = 16.00;
    91. 

  91.     value = UnitedNumberMap[css_line_height_string];
    92. 

  92.     if (value) {
    93. 

  93.       return value;
    94. 

  94.     }
    95. 

  95.     value = {
    96. 

  96.       "xx-small": 9,
    97. 

  97.       "x-small": 11,
    98. 

  98.       small: 13,
    99. 

  99.       medium: 16,
    100. 

  100.       large: 19,
    101. 

  101.       "x-large": 23,
    102. 

  102.       "xx-large": 28,
    103. 

  103.       auto: 0
    104. 

  104.     }[{
    105. 

  105.       css_line_height_string: css_line_height_string
    106. 

  106.     }];
    107. 

  107.     if (value !== undef) {
    108. 

  108.       return UnitedNumberMap[css_line_height_string] = value / normal;
    109. 

  109.     }
    110. 

  110.     if (value = parseFloat(css_line_height_string)) {
    111. 

  111.       return UnitedNumberMap[css_line_height_string] = value / normal;
    112. 

  112.     }
    113. 

  113.     value = css_line_height_string.match(/([\d\.]+)(px)/);
    114. 

  114.     if (value.length === 3) {
    115. 

  115.       return UnitedNumberMap[css_line_height_string] = parseFloat(value[1]) / normal;
    116. 

  116.     }
    117. 

  117.     return UnitedNumberMap[css_line_height_string] = 1;
    118. 

  118.   };
    119. 

  119.   GetCSS = function(element) {
    120. 

  120.     var css, tmp, computedCSSElement;
    121. 

  121.     computedCSSElement = (function(el) {
    122. 

  122.       var compCSS;
    123. 

  123.       compCSS = (function(el) {
    124. 

  124.         if ( document.defaultView && document.defaultView.getComputedStyle ) {
    125. 

  125.           return document.defaultView.getComputedStyle(el, null);
    126. 

  126.         } else if ( el.currentStyle ) {
    127. 

  127.           return el.currentStyle;
    128. 

  128.         } else {
    129. 

  129.           return el.style;
    130. 

  130.         }
    131. 

  131.       })(el);
    132. 

  132.       return function(prop) {
    133. 

  133.         prop = prop.replace(/-\D/g, function(match){
    134. 

  134.           return match.charAt(1).toUpperCase();
    135. 

  135.         })
    136. 

  136.         return compCSS[prop];
    137. 

  137.       }
    138. 

  138.     })(element);
    139. 

  139.     css = {};
    140. 

  140.     tmp = void 0;
    141. 

  141.     css["font-family"] = ResolveFont(computedCSSElement("font-family")) || "times";
    142. 

  142.     css["font-style"] = FontStyleMap[computedCSSElement("font-style")] || "normal";
    143. 

  143.     tmp = FontWeightMap[computedCSSElement("font-weight")] || "normal";
    144. 

  144.     if (tmp === "bold") {
    145. 

  145.       if (css["font-style"] === "normal") {
    146. 

  146.         css["font-style"] = tmp;
    147. 

  147.       } else {
    148. 

  148.         css["font-style"] = tmp + css["font-style"];
    149. 

  149.       }
    150. 

  150.     }
    151. 

  151.     css["font-size"] = ResolveUnitedNumber(computedCSSElement("font-size")) || 1;
    152. 

  152.     css["line-height"] = ResolveUnitedNumber(computedCSSElement("line-height")) || 1;
    153. 

  153.     css["display"] = (computedCSSElement("display") === "inline" ? "inline" : "block");
    154. 

  154.     if (css["display"] === "block") {
    155. 

  155.       css["margin-top"] = ResolveUnitedNumber(computedCSSElement("margin-top")) || 0;
    156. 

  156.       css["margin-bottom"] = ResolveUnitedNumber(computedCSSElement("margin-bottom")) || 0;
    157. 

  157.       css["padding-top"] = ResolveUnitedNumber(computedCSSElement("padding-top")) || 0;
    158. 

  158.       css["padding-bottom"] = ResolveUnitedNumber(computedCSSElement("padding-bottom")) || 0;
    159. 

  159.       css["margin-left"] = ResolveUnitedNumber(computedCSSElement("margin-left")) || 0;
    160. 

  160.       css["margin-right"] = ResolveUnitedNumber(computedCSSElement("margin-right")) || 0;
    161. 

  161.       css["padding-left"] = ResolveUnitedNumber(computedCSSElement("padding-left")) || 0;
    162. 

  162.       css["padding-right"] = ResolveUnitedNumber(computedCSSElement("padding-right")) || 0;
    163. 

  163.     }
    164. 

  164.     return css;
    165. 

  165.   };
    166. 

  166.   elementHandledElsewhere = function(element, renderer, elementHandlers) {
    167. 

  167.     var handlers, i, isHandledElsewhere, l, t;
    168. 

  168.     isHandledElsewhere = false;
    169. 

  169.     i = void 0;
    170. 

  170.     l = void 0;
    171. 

  171.     t = void 0;
    172. 

  172.     handlers = elementHandlers["#" + element.id];
    173. 

  173.     if (handlers) {
    174. 

  174.       if (typeof handlers === "function") {
    175. 

  175.         isHandledElsewhere = handlers(element, renderer);
    176. 

  176.       } else {
    177. 

  177.         i = 0;
    178. 

  178.         l = handlers.length;
    179. 

  179.         while (!isHandledElsewhere && i !== l) {
    180. 

  180.           isHandledElsewhere = handlers[i](element, renderer);
    181. 

  181.           i++;
    182. 

  182.         }
    183. 

  183.       }
    184. 

  184.     }
    185. 

  185.     handlers = elementHandlers[element.nodeName];
    186. 

  186.     if (!isHandledElsewhere && handlers) {
    187. 

  187.       if (typeof handlers === "function") {
    188. 

  188.         isHandledElsewhere = handlers(element, renderer);
    189. 

  189.       } else {
    190. 

  190.         i = 0;
    191. 

  191.         l = handlers.length;
    192. 

  192.         while (!isHandledElsewhere && i !== l) {
    193. 

  193.           isHandledElsewhere = handlers[i](element, renderer);
    194. 

  194.           i++;
    195. 

  195.         }
    196. 

  196.       }
    197. 

  197.     }
    198. 

  198.     return isHandledElsewhere;
    199. 

  199.   };
    200. 

  200.   tableToJson = function(table, renderer) {
    201. 

  201.     var data, headers, i, j, rowData, tableRow, table_obj, table_with, cell, l;
    202. 

  202.     data = [];
    203. 

  203.     headers = [];
    204. 

  204.     i = 0;
    205. 

  205.     l = table.rows[0].cells.length;
    206. 

  206.     table_with = table.clientWidth;
    207. 

  207.     while (i < l) {
    208. 

  208.       cell = table.rows[0].cells[i];
    209. 

  209.       headers[i] = {
    210. 

  210.         name: cell.textContent.toLowerCase().replace(/\s+/g,''),
    211. 

  211.         prompt: cell.textContent.replace(/\r?\n/g,''),
    212. 

  212.         width: (cell.clientWidth / table_with) * renderer.pdf.internal.pageSize.width
    213. 

  213.       };
    214. 

  214.       i++;
    215. 

  215.     }
    216. 

  216.     i = 1;
    217. 

  217.     while (i < table.rows.length) {
    218. 

  218.       tableRow = table.rows[i];
    219. 

  219.       rowData = {};
    220. 

  220.       j = 0;
    221. 

  221.       while (j < tableRow.cells.length) {
    222. 

  222.         rowData[headers[j].name] = tableRow.cells[j].textContent.replace(/\r?\n/g,'');
    223. 

  223.         j++;
    224. 

  224.       }
    225. 

  225.       data.push(rowData);
    226. 

  226.       i++;
    227. 

  227.     }
    228. 

  228.     return table_obj = {
    229. 

  229.       rows: data,
    230. 

  230.       headers: headers
    231. 

  231.     };
    232. 

  232.   };
    233. 

  233.   var SkipNode = {
    234. 

  234.     SCRIPT   : 1,
    235. 

  235.     STYLE    : 1,
    236. 

  236.     NOSCRIPT : 1,
    237. 

  237.     OBJECT   : 1,
    238. 

  238.     EMBED    : 1
    239. 

  239.   };
    240. 

  240.   DrillForContent = function(element, renderer, elementHandlers) {
    241. 

  241.     var cn, cns, fragmentCSS, i, isBlock, l, px2pt, table2json;
    242. 

  242.     cns = element.childNodes;
    243. 

  243.     cn = void 0;
    244. 

  244.     fragmentCSS = GetCSS(element);
    245. 

  245.     isBlock = fragmentCSS.display === "block";
    246. 

  246.     if (isBlock) {
    247. 

  247.       renderer.setBlockBoundary();
    248. 

  248.       renderer.setBlockStyle(fragmentCSS);
    249. 

  249.     }
    250. 

  250.     px2pt = 0.264583 * 72 / 25.4;
    251. 

  251.     i = 0;
    252. 

  252.     l = cns.length;
    253. 

  253.     while (i < l) {
    254. 

  254.       cn = cns[i];
    255. 

  255.       if (typeof cn === "object") {
    256. 

  256.         if (cn.nodeType === 8 && cn.nodeName === "#comment") {
    257. 

  257.           if (cn.textContent.match("ADD_PAGE")) {
    258. 

  258.             renderer.pdf.addPage();
    259. 

  259.             renderer.y = renderer.pdf.margins_doc.top;
    260. 

  260.           }
    261. 

  261.         } else if (cn.nodeType === 1 && !SkipNode[cn.nodeName]) {
    262. 

  262.           if (cn.nodeName === "IMG" && images[cn.getAttribute("src")]) {
    263. 

  263.             if ((renderer.pdf.internal.pageSize.height - renderer.pdf.margins_doc.bottom < renderer.y + cn.height) && (renderer.y > renderer.pdf.margins_doc.top)) {
    264. 

  264.               renderer.pdf.addPage();
    265. 

  265.               renderer.y = renderer.pdf.margins_doc.top;
    266. 

  266.             }
    267. 

  267.             renderer.pdf.addImage(images[cn.getAttribute("src")], renderer.x, renderer.y, cn.width, cn.height);
    268. 

  268.             renderer.y += cn.height;
    269. 

  269.           } else if (cn.nodeName === "TABLE") {
    270. 

  270.             table2json = tableToJson(cn, renderer);
    271. 

  271.             renderer.y += 10;
    272. 

  272.             renderer.pdf.table(renderer.x, renderer.y, table2json.rows, table2json.headers, {
    273. 

  273.               autoSize: false,
    274. 

  274.               printHeaders: true,
    275. 

  275.               margins: renderer.pdf.margins_doc
    276. 

  276.             });
    277. 

  277.             renderer.y = renderer.pdf.lastCellPos.y + renderer.pdf.lastCellPos.h + 20;
    278. 

  278.           } else {
    279. 

  279.             if (!elementHandledElsewhere(cn, renderer, elementHandlers)) {
    280. 

  280.               DrillForContent(cn, renderer, elementHandlers);
    281. 

  281.             }
    282. 

  282.           }
    283. 

  283.         } else if (cn.nodeType === 3) {
    284. 

  284.           renderer.addText(cn.nodeValue, fragmentCSS);
    285. 

  285.         } else if (typeof cn === "string") {
    286. 

  286.           renderer.addText(cn, fragmentCSS);
    287. 

  287.         }
    288. 

  288.       }
    289. 

  289.       i++;
    290. 

  290.     }
    291. 

  291.     if (isBlock) {
    292. 

  292.       return renderer.setBlockBoundary();
    293. 

  293.     }
    294. 

  294.   };
    295. 

  295.   images = {};
    296. 

  296.   loadImgs = function(element, renderer, elementHandlers, cb) {
    297. 

  297.     var imgs = element.getElementsByTagName('img'), l = imgs.length, x = 0;
    298. 

  298.     function done() {
    299. 

  299.       DrillForContent(element, renderer, elementHandlers);
    300. 

  300.       cb(renderer.dispose());
    301. 

  301.     }
    302. 

  302.     function loadImage(url) {
    303. 

  303.       if(!url) return;
    304. 

  304.       var img = new Image();
    305. 

  305.       ++x;img.crossOrigin='';
    306. 

  306.       img.onerror = img.onload = function() {
    307. 

  307.         if(img.complete && img.width + img.height)
    308. 

  308.           images[url] = images[url] || img;
    309. 

  309.         if(!--x) done();
    310. 

  310.       };
    311. 

  311.       img.src = url;
    312. 

  312.     }
    313. 

  313.     while(l--)
    314. 

  314.       loadImage(imgs[l].getAttribute("src"));
    315. 

  315.     cb = cb || function() {};
    316. 

  316.     return x || done();
    317. 

  317.   };
    318. 

  318.   process = function(pdf, element, x, y, settings, callback) {
    319. 

  319.     if (!element) return false;
    320. 

  320.     if (!element.parentNode) element = '' + element.innerHTML;
    321. 

  321.     if (typeof element === "string") {
    322. 

  322.       element = (function(element) {
    323. 

  323.         var $frame, $hiddendiv, framename, visuallyhidden;
    324. 

  324.         framename = "jsPDFhtmlText" + Date.now().toString() + (Math.random() * 1000).toFixed(0);
    325. 

  325.         visuallyhidden = "position: absolute !important;" + "clip: rect(1px 1px 1px 1px); /* IE6, IE7 */" + "clip: rect(1px, 1px, 1px, 1px);" + "padding:0 !important;" + "border:0 !important;" + "height: 1px !important;" + "width: 1px !important; " + "top:auto;" + "left:-100px;" + "overflow: hidden;";
    326. 

  326.         $hiddendiv = document.createElement('div');
    327. 

  327.         $hiddendiv.style.cssText = visuallyhidden;
    328. 

  328.         $hiddendiv.innerHTML = "<iframe style=\"height:1px;width:1px\" name=\"" + framename + "\" />";
    329. 

  329.         document.body.appendChild($hiddendiv);
    330. 

  330.         $frame = window.frames[framename];
    331. 

  331.         $frame.document.body.innerHTML = element;
    332. 

  332.         return $frame.document.body;
    333. 

  333.       })(element.replace(/<\/?script[^>]*?>/gi,''));
    334. 

  334.     }
    335. 

  335.     var r = new Renderer(pdf, x, y, settings);
    336. 

  336.     loadImgs.call(this, element, r, settings.elementHandlers, callback);
    337. 

  337.     return r.dispose();
    338. 

  338.   };
    339. 

  339.   Renderer.prototype.init = function() {
    340. 

  340.     this.paragraph = {
    341. 

  341.       text: [],
    342. 

  342.       style: []
    343. 

  343.     };
    344. 

  344.     return this.pdf.internal.write("q");
    345. 

  345.   };
    346. 

  346.   Renderer.prototype.dispose = function() {
    347. 

  347.     this.pdf.internal.write("Q");
    348. 

  348.     return {
    349. 

  349.       x: this.x,
    350. 

  350.       y: this.y
    351. 

  351.     };
    352. 

  352.   };
    353. 

  353.   Renderer.prototype.splitFragmentsIntoLines = function(fragments, styles) {
    354. 

  354.     var currentLineLength, defaultFontSize, ff, fontMetrics, fontMetricsCache, fragment, fragmentChopped, fragmentLength, fragmentSpecificMetrics, fs, k, line, lines, maxLineLength, style;
    355. 

  355.     defaultFontSize = 12;
    356. 

  356.     k = this.pdf.internal.scaleFactor;
    357. 

  357.     fontMetricsCache = {};
    358. 

  358.     ff = void 0;
    359. 

  359.     fs = void 0;
    360. 

  360.     fontMetrics = void 0;
    361. 

  361.     fragment = void 0;
    362. 

  362.     style = void 0;
    363. 

  363.     fragmentSpecificMetrics = void 0;
    364. 

  364.     fragmentLength = void 0;
    365. 

  365.     fragmentChopped = void 0;
    366. 

  366.     line = [];
    367. 

  367.     lines = [line];
    368. 

  368.     currentLineLength = 0;
    369. 

  369.     maxLineLength = this.settings.width;
    370. 

  370.     while (fragments.length) {
    371. 

  371.       fragment = fragments.shift();
    372. 

  372.       style = styles.shift();
    373. 

  373.       if (fragment) {
    374. 

  374.         ff = style["font-family"];
    375. 

  375.         fs = style["font-style"];
    376. 

  376.         fontMetrics = fontMetricsCache[ff + fs];
    377. 

  377.         if (!fontMetrics) {
    378. 

  378.           fontMetrics = this.pdf.internal.getFont(ff, fs).metadata.Unicode;
    379. 

  379.           fontMetricsCache[ff + fs] = fontMetrics;
    380. 

  380.         }
    381. 

  381.         fragmentSpecificMetrics = {
    382. 

  382.           widths: fontMetrics.widths,
    383. 

  383.           kerning: fontMetrics.kerning,
    384. 

  384.           fontSize: style["font-size"] * defaultFontSize,
    385. 

  385.           textIndent: currentLineLength
    386. 

  386.         };
    387. 

  387.         fragmentLength = this.pdf.getStringUnitWidth(fragment, fragmentSpecificMetrics) * fragmentSpecificMetrics.fontSize / k;
    388. 

  388.         if (currentLineLength + fragmentLength > maxLineLength) {
    389. 

  389.           fragmentChopped = this.pdf.splitTextToSize(fragment, maxLineLength, fragmentSpecificMetrics);
    390. 

  390.           line.push([fragmentChopped.shift(), style]);
    391. 

  391.           while (fragmentChopped.length) {
    392. 

  392.             line = [[fragmentChopped.shift(), style]];
    393. 

  393.             lines.push(line);
    394. 

  394.           }
    395. 

  395.           currentLineLength = this.pdf.getStringUnitWidth(line[0][0], fragmentSpecificMetrics) * fragmentSpecificMetrics.fontSize / k;
    396. 

  396.         } else {
    397. 

  397.           line.push([fragment, style]);
    398. 

  398.           currentLineLength += fragmentLength;
    399. 

  399.         }
    400. 

  400.       }
    401. 

  401.     }
    402. 

  402.     return lines;
    403. 

  403.   };
    404. 

  404.   Renderer.prototype.RenderTextFragment = function(text, style) {
    405. 

  405.     var defaultFontSize, font;
    406. 

  406.     if (this.pdf.internal.pageSize.height - this.pdf.margins_doc.bottom < this.y + this.pdf.internal.getFontSize()) {
    407. 

  407.       this.pdf.internal.write("ET", "Q");
    408. 

  408.       this.pdf.addPage();
    409. 

  409.       this.y = this.pdf.margins_doc.top;
    410. 

  410.       this.pdf.internal.write("q", "BT", this.pdf.internal.getCoordinateString(this.x), this.pdf.internal.getVerticalCoordinateString(this.y), "Td");
    411. 

  411.     }
    412. 

  412.     defaultFontSize = 12;
    413. 

  413.     font = this.pdf.internal.getFont(style["font-family"], style["font-style"]);
    414. 

  414.     return this.pdf.internal.write("/" + font.id, (defaultFontSize * style["font-size"]).toFixed(2), "Tf", "(" + this.pdf.internal.pdfEscape(text) + ") Tj");
    415. 

  415.   };
    416. 

  416.   Renderer.prototype.renderParagraph = function() {
    417. 

  417.     var blockstyle, defaultFontSize, fontToUnitRatio, fragments, i, l, line, lines, maxLineHeight, out, paragraphspacing_after, paragraphspacing_before, priorblockstype, styles;
    418. 

  418.     fragments = PurgeWhiteSpace(this.paragraph.text);
    419. 

  419.     styles = this.paragraph.style;
    420. 

  420.     blockstyle = this.paragraph.blockstyle;
    421. 

  421.     priorblockstype = this.paragraph.blockstyle || {};
    422. 

  422.     this.paragraph = {
    423. 

  423.       text: [],
    424. 

  424.       style: [],
    425. 

  425.       blockstyle: {},
    426. 

  426.       priorblockstyle: blockstyle
    427. 

  427.     };
    428. 

  428.     if (!fragments.join("").trim()) {
    429. 

  429.       return;
    430. 

  430.     }
    431. 

  431.     lines = this.splitFragmentsIntoLines(fragments, styles);
    432. 

  432.     line = void 0;
    433. 

  433.     maxLineHeight = void 0;
    434. 

  434.     defaultFontSize = 12;
    435. 

  435.     fontToUnitRatio = defaultFontSize / this.pdf.internal.scaleFactor;
    436. 

  436.     paragraphspacing_before = (Math.max((blockstyle["margin-top"] || 0) - (priorblockstype["margin-bottom"] || 0), 0) + (blockstyle["padding-top"] || 0)) * fontToUnitRatio;
    437. 

  437.     paragraphspacing_after = ((blockstyle["margin-bottom"] || 0) + (blockstyle["padding-bottom"] || 0)) * fontToUnitRatio;
    438. 

  438.     out = this.pdf.internal.write;
    439. 

  439.     i = void 0;
    440. 

  440.     l = void 0;
    441. 

  441.     this.y += paragraphspacing_before;
    442. 

  442.     out("q", "BT", this.pdf.internal.getCoordinateString(this.x), this.pdf.internal.getVerticalCoordinateString(this.y), "Td");
    443. 

  443.     while (lines.length) {
    444. 

  444.       line = lines.shift();
    445. 

  445.       maxLineHeight = 0;
    446. 

  446.       i = 0;
    447. 

  447.       l = line.length;
    448. 

  448.       while (i !== l) {
    449. 

  449.         if (line[i][0].trim()) {
    450. 

  450.           maxLineHeight = Math.max(maxLineHeight, line[i][1]["line-height"], line[i][1]["font-size"]);
    451. 

  451.         }
    452. 

  452.         i++;
    453. 

  453.       }
    454. 

  454.       out(0, (-1 * defaultFontSize * maxLineHeight).toFixed(2), "Td");
    455. 

  455.       i = 0;
    456. 

  456.       l = line.length;
    457. 

  457.       while (i !== l) {
    458. 

  458.         if (line[i][0]) {
    459. 

  459.           this.RenderTextFragment(line[i][0], line[i][1]);
    460. 

  460.         }
    461. 

  461.         i++;
    462. 

  462.       }
    463. 

  463.       this.y += maxLineHeight * fontToUnitRatio;
    464. 

  464.     }
    465. 

  465.     out("ET", "Q");
    466. 

  466.     return this.y += paragraphspacing_after;
    467. 

  467.   };
    468. 

  468.   Renderer.prototype.setBlockBoundary = function() {
    469. 

  469.     return this.renderParagraph();
    470. 

  470.   };
    471. 

  471.   Renderer.prototype.setBlockStyle = function(css) {
    472. 

  472.     return this.paragraph.blockstyle = css;
    473. 

  473.   };
    474. 

  474.   Renderer.prototype.addText = function(text, css) {
    475. 

  475.     this.paragraph.text.push(text);
    476. 

  476.     return this.paragraph.style.push(css);
    477. 

  477.   };
    478. 

  478.   FontNameDB = {
    479. 

  479.     helvetica: "helvetica",
    480. 

  480.     "sans-serif": "helvetica",
    481. 

  481.     serif: "times",
    482. 

  482.     times: "times",
    483. 

  483.     "times new roman": "times",
    484. 

  484.     monospace: "courier",
    485. 

  485.     courier: "courier"
    486. 

  486.   };
    487. 

  487.   FontWeightMap = {
    488. 

  488.     100: "normal",
    489. 

  489.     200: "normal",
    490. 

  490.     300: "normal",
    491. 

  491.     400: "normal",
    492. 

  492.     500: "bold",
    493. 

  493.     600: "bold",
    494. 

  494.     700: "bold",
    495. 

  495.     800: "bold",
    496. 

  496.     900: "bold",
    497. 

  497.     normal: "normal",
    498. 

  498.     bold: "bold",
    499. 

  499.     bolder: "bold",
    500. 

  500.     lighter: "normal"
    501. 

  501.   };
    502. 

  502.   FontStyleMap = {
    503. 

  503.     normal: "normal",
    504. 

  504.     italic: "italic",
    505. 

  505.     oblique: "italic"
    506. 

  506.   };
    507. 

  507.   UnitedNumberMap = {
    508. 

  508.     normal: 1
    509. 

  509.     /*
    510. 

  510.       Converts HTML-formatted text into formatted PDF text.
    511. 

    512. 

  512.       Notes:
    513. 

  513.       2012-07-18
    514. 

  514.       Plugin relies on having browser, DOM around. The HTML is pushed into dom and traversed.
    515. 

  515.       Plugin relies on jQuery for CSS extraction.
    516. 

  516.       Targeting HTML output from Markdown templating, which is a very simple
    517. 

  517.       markup - div, span, em, strong, p. No br-based paragraph separation supported explicitly (but still may work.)
    518. 

  518.       Images, tables are NOT supported.
    519. 

    520. 

  520.       @public
    521. 

  521.       @function
    522. 

  522.       @param HTML {String or DOM Element} HTML-formatted text, or pointer to DOM element that is to be rendered into PDF.
    523. 

  523.       @param x {Number} starting X coordinate in jsPDF instance's declared units.
    524. 

  524.       @param y {Number} starting Y coordinate in jsPDF instance's declared units.
    525. 

  525.       @param settings {Object} Additional / optional variables controlling parsing, rendering.
    526. 

  526.       @returns {Object} jsPDF instance
    527. 

  527.     */
    528. 

  528.   };
    529. 

  529.   return jsPDFAPI.fromHTML = function(HTML, x, y, settings, callback, margins) {
    530. 

  530.     "use strict";
    531. 

  531.     this.margins_doc = margins || {top:0,bottom:0};
    532. 

  532.     if(!settings) settings = {};
    533. 

  533.     if(!settings.elementHandlers) settings.elementHandlers = {};
    534. 

  534.     return process(this, HTML, x || 4, y || 4, settings, callback);
    535. 

  535.   };
    536. 

  536. })(jsPDF.API);
    537.