@marcusumn/html2pdf.js 0.1.0

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@marcusumn/html2pdf.js",
+  "version": "0.1.0",
+  "description": "Maintained fork of html2pdf.js - client-side HTML-to-PDF rendering using pure JS",
+  "main": "dist/html2pdf.js",
+  "types": "./type.d.ts",
+  "files": [
+    "/src",
+    "/dist",
+    "./type.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MarcusUMN/html2pdf.js.git"
+  },
+  "keywords": [
+    "javascript",
+    "pdf-generation",
+    "html",
+    "client-side",
+    "canvas"
+  ],
+  "author": {
+    "name": "Erik Koopmans",
+    "email": "erik@erik-koopmans.com",
+    "url": "https://www.erik-koopmans.com"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/MarcusUMN/html2pdf.js/issues"
+  },
+  "homepage": "https://marcusumn.github.io/html2pdf.js/",
+  "dependencies": {
+    "html2canvas": "^1.0.0",
+    "jspdf": "^4.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.14.8",
+    "@babel/preset-env": "^7.14.8",
+    "@brightspace-ui/core": "^3.156.4",
+    "@brightspace-ui/testing": "^1.31.2",
+    "@web/dev-server": "^0.4.6",
+    "babel-loader": "^10.0.0",
+    "core-js": "^3.16.0",
+    "lit": "^3.3.1",
+    "pdfjs-dist": "^5.3.93",
+    "rimraf": "^6.0.1",
+    "sinon": "^21.0.0",
+    "webpack": "^5.101.0",
+    "webpack-bundle-analyzer": "^4.4.2",
+    "webpack-cli": "^6.0.1"
+  },
+  "scripts": {
+    "build": "npm run clean && webpack --env=prod",
+    "build:analyze": "npm run clean && webpack --env=prod --env=analyzer",
+    "clean": "rimraf dist",
+    "dev": "webpack --env=dev",
+    "dev:analyze": "webpack --env=dev --env=analyzer",
+    "start": "web-dev-server --open demo/ --node-resolve --watch",
+    "test": "npm run test:unit && npm run test:vdiff",
+    "test:unit": "d2l-test-runner --chrome",
+    "test:vdiff": "d2l-test-runner vdiff",
+    "test:vdiff:golden": "d2l-test-runner vdiff golden"
+  }
+}

package/src/index.js

@@ -0,0 +1,29 @@
+import Worker from './worker.js';
+import './plugin/jspdf-plugin.js';
+import './plugin/pagebreaks.js';
+import './plugin/hyperlinks.js';
+
+/**
+ * Generate a PDF from an HTML element or string using html2canvas and jsPDF.
+ *
+ * @param {Element|string} source The source element or HTML string.
+ * @param {Object=} opt An object of optional settings: 'margin', 'filename',
+ *    'image' ('type' and 'quality'), and 'html2canvas' / 'jspdf', which are
+ *    sent as settings to their corresponding functions.
+ */
+var html2pdf = function html2pdf(src, opt) {
+  // Create a new worker with the given options.
+  var worker = new html2pdf.Worker(opt);
+
+  if (src) {
+    // If src is specified, perform the traditional 'simple' operation.
+    return worker.from(src).save();
+  } else {
+    // Otherwise, return the worker for new Promise-based operation.
+    return worker;
+  }
+}
+html2pdf.Worker = Worker;
+
+// Expose the html2pdf function.
+export default html2pdf;

package/src/plugin/hyperlinks.js

@@ -0,0 +1,59 @@
+import Worker from '../worker.js';
+import { unitConvert } from '../utils.js';
+
+// Add hyperlink functionality to the PDF creation.
+
+// Main link array, and refs to original functions.
+var linkInfo = [];
+var orig = {
+  toContainer: Worker.prototype.toContainer,
+  toPdf: Worker.prototype.toPdf,
+};
+
+Worker.prototype.toContainer = function toContainer() {
+  return orig.toContainer.call(this).then(function toContainer_hyperlink() {
+    // Retrieve hyperlink info if the option is enabled.
+    if (this.opt.enableLinks) {
+      // Find all anchor tags and get the container's bounds for reference.
+      var container = this.prop.container;
+      var links = container.querySelectorAll('a');
+      var containerRect = unitConvert(container.getBoundingClientRect(), this.prop.pageSize.k);
+      linkInfo = [];
+
+      // Loop through each anchor tag.
+      Array.prototype.forEach.call(links, function(link) {
+        // Treat each client rect as a separate link (for text-wrapping).
+        var clientRects = link.getClientRects();
+        for (var i=0; i<clientRects.length; i++) {
+          var clientRect = unitConvert(clientRects[i], this.prop.pageSize.k);
+          clientRect.left -= containerRect.left;
+          clientRect.top -= containerRect.top;
+
+          var page = Math.floor(clientRect.top / this.prop.pageSize.inner.height) + 1;
+          var top = this.opt.margin[0] + clientRect.top % this.prop.pageSize.inner.height;
+          var left = this.opt.margin[1] + clientRect.left;
+
+          linkInfo.push({ page, top, left, clientRect, link });
+        }
+      }, this);
+    }
+  });
+};
+
+Worker.prototype.toPdf = function toPdf() {
+  return orig.toPdf.call(this).then(function toPdf_hyperlink() {
+    // Add hyperlinks if the option is enabled.
+    if (this.opt.enableLinks) {
+      // Attach each anchor tag based on info from toContainer().
+      linkInfo.forEach(function(l) {
+        this.prop.pdf.setPage(l.page);
+        this.prop.pdf.link(l.left, l.top, l.clientRect.width, l.clientRect.height,
+                           { url: l.link.href });
+      }, this);
+
+      // Reset the active page of the PDF to the final page.
+      var nPages = this.prop.pdf.internal.getNumberOfPages();
+      this.prop.pdf.setPage(nPages);
+    }
+  });
+};

package/src/plugin/jspdf-plugin.js

@@ -0,0 +1,99 @@
+// Import dependencies.
+import jsPDF from 'jspdf/dist/jspdf.es.min.js';
+
+// Get dimensions of a PDF page, as determined by jsPDF.
+jsPDF.getPageSize = function(orientation, unit, format) {
+  // Decode options object
+  if (typeof orientation === 'object') {
+    var options = orientation;
+    orientation = options.orientation;
+    unit = options.unit || unit;
+    format = options.format || format;
+  }
+
+  // Default options
+  unit        = unit || 'mm';
+  format      = format || 'a4';
+  orientation = ('' + (orientation || 'P')).toLowerCase();
+  var format_as_string = ('' + format).toLowerCase();
+
+  // Size in pt of various paper formats
+  var pageFormats = {
+    'a0'  : [2383.94, 3370.39], 'a1'  : [1683.78, 2383.94],
+    'a2'  : [1190.55, 1683.78], 'a3'  : [ 841.89, 1190.55],
+    'a4'  : [ 595.28,  841.89], 'a5'  : [ 419.53,  595.28],
+    'a6'  : [ 297.64,  419.53], 'a7'  : [ 209.76,  297.64],
+    'a8'  : [ 147.40,  209.76], 'a9'  : [ 104.88,  147.40],
+    'a10' : [  73.70,  104.88], 'b0'  : [2834.65, 4008.19],
+    'b1'  : [2004.09, 2834.65], 'b2'  : [1417.32, 2004.09],
+    'b3'  : [1000.63, 1417.32], 'b4'  : [ 708.66, 1000.63],
+    'b5'  : [ 498.90,  708.66], 'b6'  : [ 354.33,  498.90],
+    'b7'  : [ 249.45,  354.33], 'b8'  : [ 175.75,  249.45],
+    'b9'  : [ 124.72,  175.75], 'b10' : [  87.87,  124.72],
+    'c0'  : [2599.37, 3676.54], 'c1'  : [1836.85, 2599.37],
+    'c2'  : [1298.27, 1836.85], 'c3'  : [ 918.43, 1298.27],
+    'c4'  : [ 649.13,  918.43], 'c5'  : [ 459.21,  649.13],
+    'c6'  : [ 323.15,  459.21], 'c7'  : [ 229.61,  323.15],
+    'c8'  : [ 161.57,  229.61], 'c9'  : [ 113.39,  161.57],
+    'c10' : [  79.37,  113.39], 'dl'  : [ 311.81,  623.62],
+    'letter'            : [612,   792],
+    'government-letter' : [576,   756],
+    'legal'             : [612,  1008],
+    'junior-legal'      : [576,   360],
+    'ledger'            : [1224,  792],
+    'tabloid'           : [792,  1224],
+    'credit-card'       : [153,   243]
+  };
+
+  // Unit conversion
+  switch (unit) {
+    case 'pt':  var k = 1;          break;
+    case 'mm':  var k = 72 / 25.4;  break;
+    case 'cm':  var k = 72 / 2.54;  break;
+    case 'in':  var k = 72;         break;
+    case 'px':  var k = 72 / 96;    break;
+    case 'pc':  var k = 12;         break;
+    case 'em':  var k = 12;         break;
+    case 'ex':  var k = 6;          break;
+    default:
+      throw ('Invalid unit: ' + unit);
+  }
+
+  // Dimensions are stored as user units and converted to points on output
+  if (pageFormats.hasOwnProperty(format_as_string)) {
+    var pageHeight = pageFormats[format_as_string][1] / k;
+    var pageWidth = pageFormats[format_as_string][0] / k;
+  } else {
+    try {
+      var pageHeight = format[1];
+      var pageWidth = format[0];
+    } catch (err) {
+      throw new Error('Invalid format: ' + format);
+    }
+  }
+
+  // Handle page orientation
+  if (orientation === 'p' || orientation === 'portrait') {
+    orientation = 'p';
+    if (pageWidth > pageHeight) {
+      var tmp = pageWidth;
+      pageWidth = pageHeight;
+      pageHeight = tmp;
+    }
+  } else if (orientation === 'l' || orientation === 'landscape') {
+    orientation = 'l';
+    if (pageHeight > pageWidth) {
+      var tmp = pageWidth;
+      pageWidth = pageHeight;
+      pageHeight = tmp;
+    }
+  } else {
+    throw('Invalid orientation: ' + orientation);
+  }
+
+  // Return information (k is the unit conversion ratio from pts)
+  var info = { 'width': pageWidth, 'height': pageHeight, 'unit': unit, 'k': k };
+  return info;
+};
+
+export default jsPDF;

package/src/plugin/pagebreaks.js

@@ -0,0 +1,134 @@
+import Worker from '../worker.js';
+import { objType, createElement } from '../utils.js';
+
+/* Pagebreak plugin:
+
+    Adds page-break functionality to the html2pdf library. Page-breaks can be
+    enabled by CSS styles, set on individual elements using selectors, or
+    avoided from breaking inside all elements.
+
+    Options on the `opt.pagebreak` object:
+
+    mode:   String or array of strings: 'avoid-all', 'css', and/or 'legacy'
+            Default: ['css', 'legacy']
+
+    before: String or array of CSS selectors for which to add page-breaks
+            before each element. Can be a specific element with an ID
+            ('#myID'), all elements of a type (e.g. 'img'), all of a class
+            ('.myClass'), or even '*' to match every element.
+
+    after:  Like 'before', but adds a page-break immediately after the element.
+
+    avoid:  Like 'before', but avoids page-breaks on these elements. You can
+            enable this feature on every element using the 'avoid-all' mode.
+*/
+
+// Refs to original functions.
+var orig = {
+  toContainer: Worker.prototype.toContainer
+};
+
+// Add pagebreak default options to the Worker template.
+Worker.template.opt.pagebreak = {
+  mode: ['css', 'legacy'],
+  before: [],
+  after: [],
+  avoid: []
+};
+
+Worker.prototype.toContainer = function toContainer() {
+  return orig.toContainer.call(this).then(function toContainer_pagebreak() {
+    // Setup root element and inner page height.
+    var root = this.prop.container;
+    var pxPageHeight = this.prop.pageSize.inner.px.height;
+
+    // Check all requested modes.
+    var modeSrc = [].concat(this.opt.pagebreak.mode);
+    var mode = {
+      avoidAll:   modeSrc.indexOf('avoid-all') !== -1,
+      css:        modeSrc.indexOf('css') !== -1,
+      legacy:     modeSrc.indexOf('legacy') !== -1
+    };
+
+    // Get arrays of all explicitly requested elements.
+    var select = {};
+    var self = this;
+    ['before', 'after', 'avoid'].forEach(function(key) {
+      var all = mode.avoidAll && key === 'avoid';
+      select[key] = all ? [] : [].concat(self.opt.pagebreak[key] || []);
+      if (select[key].length > 0) {
+        select[key] = Array.prototype.slice.call(
+          root.querySelectorAll(select[key].join(', ')));
+      }
+    });
+
+    // Get all legacy page-break elements.
+    var legacyEls = root.querySelectorAll('.html2pdf__page-break');
+    legacyEls = Array.prototype.slice.call(legacyEls);
+
+    // Loop through all elements.
+    var els = root.querySelectorAll('*');
+    Array.prototype.forEach.call(els, function pagebreak_loop(el) {
+      // Setup pagebreak rules based on legacy and avoidAll modes.
+      var rules = {
+        before: false,
+        after:  mode.legacy && legacyEls.indexOf(el) !== -1,
+        avoid:  mode.avoidAll
+      };
+
+      // Add rules for css mode.
+      if (mode.css) {
+        // TODO: Check if this is valid with iFrames.
+        var style = window.getComputedStyle(el);
+        // TODO: Handle 'left' and 'right' correctly.
+        // TODO: Add support for 'avoid' on breakBefore/After.
+        var breakOpt = ['always', 'page', 'left', 'right'];
+        var avoidOpt = ['avoid', 'avoid-page'];
+        rules = {
+          before: rules.before || breakOpt.indexOf(style.breakBefore || style.pageBreakBefore) !== -1,
+          after:  rules.after || breakOpt.indexOf(style.breakAfter || style.pageBreakAfter) !== -1,
+          avoid:  rules.avoid || avoidOpt.indexOf(style.breakInside || style.pageBreakInside) !== -1
+        };
+      }
+
+      // Add rules for explicit requests.
+      Object.keys(rules).forEach(function(key) {
+        rules[key] = rules[key] || select[key].indexOf(el) !== -1;
+      });
+
+      // Get element position on the screen.
+      // TODO: Subtract the top of the container from clientRect.top/bottom?
+      var clientRect = el.getBoundingClientRect();
+
+      // Avoid: Check if a break happens mid-element.
+      if (rules.avoid && !rules.before) {
+        var startPage = Math.floor(clientRect.top / pxPageHeight);
+        var endPage = Math.floor(clientRect.bottom / pxPageHeight);
+        var nPages = Math.abs(clientRect.bottom - clientRect.top) / pxPageHeight;
+
+        // Turn on rules.before if the el is broken and is at most one page long.
+        if (endPage !== startPage && nPages <= 1) {
+          rules.before = true;
+        }
+      }
+
+      // Before: Create a padding div to push the element to the next page.
+      if (rules.before) {
+        var pad = createElement('div', {style: {
+          display: 'block',
+          height: pxPageHeight - (clientRect.top % pxPageHeight) + 'px'
+        }});
+        el.parentNode.insertBefore(pad, el);
+      }
+
+      // After: Create a padding div to fill the remaining page.
+      if (rules.after) {
+        var pad = createElement('div', {style: {
+          display: 'block',
+          height: pxPageHeight - (clientRect.bottom % pxPageHeight) + 'px'
+        }});
+        el.parentNode.insertBefore(pad, el.nextSibling);
+      }
+    });
+  });
+};

package/src/snapdom/clone.js

@@ -0,0 +1,212 @@
+// https://github.com/zumerlab/snapdom
+//
+// MIT License
+//
+// Copyright (c) 2025 ZumerLab
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+/**
+ * Deep cloning utilities for DOM elements, including styles and shadow DOM.
+ * @module clone
+ */
+
+
+/**
+ * Freeze the responsive selection of an <img> that has srcset/sizes.
+ * Copies a concrete URL into `src` and removes `srcset`/`sizes` so the clone
+ * doesn't need layout to resolve a candidate.
+ * Works with <picture> because currentSrc reflects the chosen source.
+ * @param {HTMLImageElement} original - Image in the live DOM.
+ * @param {HTMLImageElement} cloned - Just-created cloned <img>.
+ */
+function freezeImgSrcset(original, cloned) {
+  try {
+    const chosen = original.currentSrc || original.src || '';
+    if (!chosen) return;
+    cloned.setAttribute('src', chosen);
+    cloned.removeAttribute('srcset');
+    cloned.removeAttribute('sizes');
+    // Hint deterministic decode/load for capture
+    cloned.loading = 'eager';
+    cloned.decoding = 'sync';
+  } catch {
+    // no-op
+  }
+}
+
+
+/**
+ * Creates a deep clone of a DOM node, including styles, shadow DOM, and special handling for excluded/placeholder/canvas nodes.
+ *
+ * @param {Node} node - Node to clone
+ * @returns {Node|null} Cloned node with styles and shadow DOM content, or null for empty text nodes or filtered elements
+ */
+
+
+export function deepCloneBasic(node) {
+  if (!node) throw new Error('Invalid node');
+
+  // Local set to avoid duplicates in slot processing
+  const clonedAssignedNodes = new Set();
+  let pendingSelectValue = null; // Track select value for later fix
+
+  // 1. Text nodes
+  if (node.nodeType === Node.TEXT_NODE) {
+    return node.cloneNode(true);
+  }
+
+  // 2. Non-element nodes (comments, etc.)
+  if (node.nodeType !== Node.ELEMENT_NODE) {
+    return node.cloneNode(true);
+  }
+
+  // 6. Special case: iframe → fallback pattern
+  if (node.tagName === "IFRAME") {
+    const fallback = document.createElement("div");
+    fallback.style.cssText = `width:${node.offsetWidth}px;height:${node.offsetHeight}px;background-image:repeating-linear-gradient(45deg,#ddd,#ddd 5px,#f9f9f9 5px,#f9f9f9 10px);display:flex;align-items:center;justify-content:center;font-size:12px;color:#555;border:1px solid #aaa;`;
+    return fallback;
+  }
+
+  // 8. Canvas → convert to image
+  if (node.tagName === "CANVAS") {
+    const dataURL = node.toDataURL();
+    const img = document.createElement("img");
+    img.src = dataURL;
+    img.width = node.width;
+    img.height = node.height;
+    return img;
+  }
+
+  // 9. Base clone (without children)
+  let clone;
+  try {
+    clone = node.cloneNode(false);
+
+    if (node.tagName === 'IMG') {
+      freezeImgSrcset(node, clone);
+    }
+  } catch (err) {
+    console.error("[Snapdom] Failed to clone node:", node, err);
+    throw err;
+  }
+
+  // Special handling: textarea (keep size and value)
+  if (node instanceof HTMLTextAreaElement) {
+    clone.textContent = node.value;
+    clone.value = node.value;
+    const rect = node.getBoundingClientRect();
+    clone.style.boxSizing = 'border-box';
+    clone.style.width = `${rect.width}px`;
+    clone.style.height = `${rect.height}px`;
+    return clone;
+  }
+
+  // Special handling: input
+  if (node instanceof HTMLInputElement) {
+    if (node.hasAttribute("value")) {
+      clone.value = node.value;
+      clone.setAttribute("value", node.value);
+    }
+    if (node.checked !== void 0) {
+      clone.checked = node.checked;
+      if (node.checked) clone.setAttribute("checked", "");
+      if (node.indeterminate) clone.indeterminate = node.indeterminate;
+    }
+    // return clone;
+  }
+
+  // Special handling: select → postpone value adjustment
+  if (node instanceof HTMLSelectElement) {
+    pendingSelectValue = node.value;
+  }
+
+  // 12. ShadowRoot logic
+  if (node.shadowRoot) {
+    const hasSlot = Array.from(node.shadowRoot.querySelectorAll("slot")).length > 0;
+
+    if (hasSlot) {
+    } else {
+      // ShadowRoot without slots: clone full content
+      const shadowFrag = document.createDocumentFragment();
+      for (const child of node.shadowRoot.childNodes) {
+        if (child.nodeType === Node.ELEMENT_NODE && child.tagName === "STYLE") {
+          continue;
+        }
+        const clonedChild = deepCloneBasic(child);
+        if (clonedChild) shadowFrag.appendChild(clonedChild);
+      }
+      clone.appendChild(shadowFrag);
+    }
+  }
+
+  // 13. Slot outside ShadowRoot
+  if (node.tagName === "SLOT") {
+    const assigned = node.assignedNodes?.({ flatten: true }) || [];
+    const nodesToClone = assigned.length > 0 ? assigned : Array.from(node.childNodes);
+    const fragment = document.createDocumentFragment();
+
+    for (const child of nodesToClone) {
+      const clonedChild = deepCloneBasic(child);
+      if (clonedChild) fragment.appendChild(clonedChild);
+    }
+    return fragment;
+  }
+
+  // 14. Clone children (light DOM), skipping duplicates
+  for (const child of node.childNodes) {
+    if (clonedAssignedNodes.has(child)) continue;
+
+    const clonedChild = deepCloneBasic(child);
+    if (clonedChild) clone.appendChild(clonedChild);
+  }
+
+  // Adjust select value after children are cloned
+  if (pendingSelectValue !== null && clone instanceof HTMLSelectElement) {
+    clone.value = pendingSelectValue;
+    for (const opt of clone.options) {
+      if (opt.value === pendingSelectValue) {
+        opt.setAttribute("selected", "");
+      } else {
+        opt.removeAttribute("selected");
+      }
+    }
+  }
+
+  // Fix scrolling (taken from prepareClone).
+  const scrollX = node.scrollLeft;
+  const scrollY = node.scrollTop;
+  const hasScroll = scrollX || scrollY;
+  if (hasScroll && clone instanceof HTMLElement) {
+    clone.style.overflow = "hidden";
+    clone.style.scrollbarWidth = "none";
+    clone.style.msOverflowStyle = "none";
+    const inner = document.createElement("div");
+    inner.style.transform = `translate(${-scrollX}px, ${-scrollY}px)`;
+    inner.style.willChange = "transform";
+    inner.style.display = "inline-block";
+    inner.style.width = "100%";
+    while (clone.firstChild) {
+      inner.appendChild(clone.firstChild);
+    }
+    clone.appendChild(inner);
+  }
+
+  return clone;
+}

package/src/utils.js

@@ -0,0 +1,47 @@
+// Determine the type of a variable/object.
+export const objType = function objType(obj) {
+  var type = typeof obj;
+  if (type === 'undefined')                                 return 'undefined';
+  else if (type === 'string' || obj instanceof String)      return 'string';
+  else if (type === 'number' || obj instanceof Number)      return 'number';
+  else if (type === 'function' || obj instanceof Function)  return 'function';
+  else if (!!obj && obj.constructor === Array)              return 'array';
+  else if (obj && obj.nodeType === 1)                       return 'element';
+  else if (type === 'object')                               return 'object';
+  else                                                      return 'unknown';
+};
+
+// Create an HTML element with optional className, innerHTML, and style.
+export const createElement = function createElement(tagName, opt) {
+  var el = document.createElement(tagName);
+  if (opt.className)  el.className = opt.className;
+  if (opt.innerHTML) {
+    el.innerHTML = opt.innerHTML;
+    var scripts = el.getElementsByTagName('script');
+    for (var i = scripts.length; i-- > 0; null) {
+      scripts[i].parentNode.removeChild(scripts[i]);
+    }
+  }
+  for (var key in opt.style) {
+    el.style[key] = opt.style[key];
+  }
+  return el;
+};
+
+// Convert units from px using the conversion value 'k' from jsPDF.
+export const unitConvert = function unitConvert(obj, k) {
+  if (objType(obj) === 'number') {
+    return obj * 72 / 96 / k;
+  } else {
+    var newObj = {};
+    for (var key in obj) {
+      newObj[key] = obj[key] * 72 / 96 / k;
+    }
+    return newObj;
+  }
+};
+
+// Convert units to px using the conversion value 'k' from jsPDF.
+export const toPx = function toPx(val, k) {
+  return Math.floor(val * k / 72 * 96);
+}