@ammarkhalidfarooq/dashboard-package 0.5.12 → 0.5.13

package/dist/index.es.js

@@ -1,5 +1,5 @@
 import React, { Suspense, lazy, useState, useEffect } from 'react';
-import { Box, Button, Menu, MenuItem, Grid, Card, CardContent, Typography, IconButton, ThemeProvider, CircularProgress, LinearProgress, TableContainer, Table, TableHead, TableRow, TableCell, TableBody, Avatar, Stack } from '@mui/material';
+import { Box, Button, Menu, MenuItem, Grid, Card, CardContent, Typography, IconButton, ThemeProvider, CircularProgress, LinearProgress, TableContainer, Table as Table$1, TableHead, TableRow, TableCell, TableBody, Avatar, Stack } from '@mui/material';
 import { MoreHoriz, MoreVert, Check, InfoOutlined, Settings, TrendingUp, Adjust, PaidOutlined, PeopleAltOutlined, FavoriteOutlined, PersonOutlined, IndeterminateCheckBoxOutlined, SearchOutlined, HighlightOff, NearMe, Email, NotInterested } from '@mui/icons-material';
 import { createTheme, useTheme } from '@mui/material/styles';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
@@ -62,6 +62,31 @@ function _arrayWithHoles(r) {
 function _arrayWithoutHoles(r) {
   if (Array.isArray(r)) return _arrayLikeToArray(r);
 }
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
 function _defineProperty(e, r, t) {
   return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
     value: t,
@@ -124,6 +149,114 @@ function _objectSpread2(e) {
   }
   return e;
 }
+function _regenerator() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  var e,
+    t,
+    r = "function" == typeof Symbol ? Symbol : {},
+    n = r.iterator || "@@iterator",
+    o = r.toStringTag || "@@toStringTag";
+  function i(r, n, o, i) {
+    var c = n && n.prototype instanceof Generator ? n : Generator,
+      u = Object.create(c.prototype);
+    return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+      var i,
+        c,
+        u,
+        f = 0,
+        p = o || [],
+        y = false,
+        G = {
+          p: 0,
+          n: 0,
+          v: e,
+          a: d,
+          f: d.bind(e, 4),
+          d: function (t, r) {
+            return i = t, c = 0, u = e, G.n = r, a;
+          }
+        };
+      function d(r, n) {
+        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+          var o,
+            i = p[t],
+            d = G.p,
+            l = i[2];
+          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+        }
+        if (o || r > 1) return a;
+        throw y = true, n;
+      }
+      return function (o, p, l) {
+        if (f > 1) throw TypeError("Generator is already running");
+        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+          try {
+            if (f = 2, i) {
+              if (c || (o = "next"), t = i[o]) {
+                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                if (!t.done) return t;
+                u = t.value, c < 2 && (c = 0);
+              } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+              i = e;
+            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+          } catch (t) {
+            i = e, c = 1, u = t;
+          } finally {
+            f = 1;
+          }
+        }
+        return {
+          value: t,
+          done: y
+        };
+      };
+    }(r, o, i), true), u;
+  }
+  var a = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  t = Object.getPrototypeOf;
+  var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+      return this;
+    }), t),
+    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  function f(e) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
+    return this;
+  }), _regeneratorDefine(u, "toString", function () {
+    return "[object Generator]";
+  }), (_regenerator = function () {
+    return {
+      w: i,
+      m: f
+    };
+  })();
+}
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  _regeneratorDefine = function (e, r, n, t) {
+    function o(r, n) {
+      _regeneratorDefine(e, r, function (e) {
+        return this._invoke(r, n, e);
+      });
+    }
+    r ? i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  }, _regeneratorDefine(e, r, n, t);
+}
 function _slicedToArray(r, e) {
   return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
 }
@@ -752,6 +885,19 @@ var Dashboard = function Dashboard(_ref) {
   });
 };
 
+function formatNumber(num) {
+  if (num >= 1000000000) {
+    return (num / 1000000000).toFixed(1).replace(/\.0$/, "") + "B";
+  }
+  if (num >= 1000000) {
+    return (num / 1000000).toFixed(1).replace(/\.0$/, "") + "M";
+  }
+  if (num >= 1000) {
+    return (num / 1000).toFixed(1).replace(/\.0$/, "") + "K";
+  }
+  return (num !== null && num !== void 0 ? num : 0).toString();
+}
+
 var OverallSection$2 = /*#__PURE__*/lazy(function () {
   return Promise.resolve().then(function () { return OverallSection$1; });
 });
@@ -791,9 +937,351 @@ var NewOverview = function NewOverview(_ref) {
     }
   }, [activeSectionProp]);
   useEffect(function () {
-    if (exportTrigger > 0) {
-      console.log("EXPORT TRIGGER");
-    }
+    if (exportTrigger <= 0) return;
+    var buildAndDownloadPdf = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var _apiData$overviewStat, _apiData$overviewStat2, _apiData$trafficSourc, _apiData$roasCard, _apiData$overviewStat3, _apiData$overviewStat4, _apiData$overviewStat5, _apiData$overviewStat6, _apiData$overviewStat7, _apiData$overviewStat8, _doc$lastAutoTable, _apiData$orderBumpDet, _apiData$upSellDetail, _apiData$downSellDeta, _apiData$referralDeta, _doc$lastAutoTable2, _yield$Promise$all, _yield$Promise$all2, jsPDF, autoTableModule, autoTable, growth, overview, dateLabel, generatedAt, generatedLabel, fmtPct, fmtSigned, doc, pageWidth, marginX, contentWidth, cardGap, cardWidth, addHeader, addFooter, metricCard, donorMixRaw, newDonorsCount, returningDonorsCount, avgGift, newDonorsObj, returningDonorsObj, totalAmount, totalCount, activeCampaignRows, trafficRows, donorMixRows, refundsData, totalRaised, netRaised, totalDonors, convRate, avgDonation, totalVisits, passThrough, refundRate, chargebackRate, page1Cards, y, trendY, donorCardTop, miscRows, safeDate, _t;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.p = _context.n) {
+            case 0:
+              _context.p = 0;
+              _context.n = 1;
+              return Promise.all([import('jspdf'), Promise.resolve().then(function () { return jspdf_plugin_autotable; })]);
+            case 1:
+              _yield$Promise$all = _context.v;
+              _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+              jsPDF = _yield$Promise$all2[0].jsPDF;
+              autoTableModule = _yield$Promise$all2[1];
+              autoTable = autoTableModule["default"] || autoTableModule.autoTable || autoTableModule;
+              growth = (apiData === null || apiData === void 0 || (_apiData$overviewStat = apiData.overviewStats) === null || _apiData$overviewStat === void 0 || (_apiData$overviewStat = _apiData$overviewStat.overview) === null || _apiData$overviewStat === void 0 ? void 0 : _apiData$overviewStat.growthPercentage) || {};
+              overview = (apiData === null || apiData === void 0 || (_apiData$overviewStat2 = apiData.overviewStats) === null || _apiData$overviewStat2 === void 0 ? void 0 : _apiData$overviewStat2.overview) || {};
+              dateLabel = dateName || "Last Period";
+              generatedAt = new Date();
+              generatedLabel = "".concat(generatedAt.toLocaleDateString(), " ").concat(generatedAt.toLocaleTimeString());
+              fmtPct = function fmtPct(value) {
+                var digits = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+                return "".concat(Number(value || 0).toFixed(digits), "%");
+              };
+              fmtSigned = function fmtSigned(value) {
+                var suffix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+                var numeric = Number(value || 0);
+                var sign = numeric > 0 ? "+" : "";
+                return "".concat(sign).concat(numeric.toFixed(2)).concat(suffix);
+              };
+              doc = new jsPDF({
+                unit: "pt",
+                format: "a4"
+              });
+              pageWidth = doc.internal.pageSize.getWidth();
+              marginX = 40;
+              contentWidth = pageWidth - marginX * 2;
+              cardGap = 10;
+              cardWidth = (contentWidth - cardGap * 2) / 3;
+              addHeader = function addHeader() {
+                doc.setFont("helvetica", "bold");
+                doc.setTextColor(17, 24, 39);
+                doc.setFontSize(18);
+                doc.text("Madinah", marginX, 34);
+                doc.setFontSize(10);
+                doc.setTextColor(75, 85, 99);
+                doc.text("PERFORMANCE REPORT", marginX, 50);
+                doc.setTextColor(17, 24, 39);
+                doc.setFontSize(13);
+                doc.text("Dashboard overview - Overall", marginX, 72);
+                doc.setFont("helvetica", "normal");
+                doc.setFontSize(10);
+                doc.setTextColor(107, 114, 128);
+                doc.text("".concat(dateLabel, " \xB7 30-day window \xB7 Generated ").concat(generatedLabel), marginX, 88);
+                var activeFilters = (apiData === null || apiData === void 0 ? void 0 : apiData.activeFilters) || "";
+                if (activeFilters) {
+                  doc.setFontSize(8.5);
+                  doc.setTextColor(55, 65, 81);
+                  doc.text("ACTIVE FILTERS ".concat(activeFilters), marginX, 100);
+                }
+              };
+              addFooter = function addFooter(pageNumber, totalPages) {
+                doc.setFont("helvetica", "normal");
+                doc.setTextColor(107, 114, 128);
+                doc.setFontSize(8.5);
+                doc.text("Confidential \xB7 Generated by Dashboard \xB7 ".concat(generatedLabel, " \xB7 Page ").concat(pageNumber, " of ").concat(totalPages, " \xB7 madinah.com"), marginX, 818);
+              };
+              metricCard = function metricCard(_ref3) {
+                var x = _ref3.x,
+                  y = _ref3.y,
+                  title = _ref3.title,
+                  value = _ref3.value,
+                  trend = _ref3.trend,
+                  detail = _ref3.detail;
+                var positive = !"".concat(trend).trim().startsWith("-");
+                doc.setDrawColor(229, 231, 235);
+                doc.setFillColor(255, 255, 255);
+                doc.roundedRect(x, y, cardWidth, 96, 6, 6, "FD");
+                doc.setFont("helvetica", "bold");
+                doc.setFontSize(9);
+                doc.setTextColor(75, 85, 99);
+                doc.text(title.toUpperCase(), x + 10, y + 16);
+                doc.setFontSize(17);
+                doc.setTextColor(17, 24, 39);
+                doc.text(value, x + 10, y + 42);
+                doc.setFont("helvetica", "normal");
+                doc.setFontSize(9.5);
+                doc.setTextColor.apply(doc, _toConsumableArray(positive ? [22, 163, 74] : [220, 38, 38]));
+                doc.text(trend, x + 10, y + 61);
+                doc.setTextColor(107, 114, 128);
+                doc.setFontSize(8.5);
+                doc.text(detail, x + 10, y + 77, {
+                  maxWidth: cardWidth - 20
+                });
+              };
+              donorMixRaw = apiData === null || apiData === void 0 ? void 0 : apiData.donorPieChartData;
+              newDonorsCount = 0;
+              returningDonorsCount = 0;
+              avgGift = 0;
+              if (Array.isArray(donorMixRaw)) {
+                newDonorsObj = donorMixRaw.find(function (d) {
+                  return d.type === "New Donors" || d.type === "New donors";
+                }) || {};
+                returningDonorsObj = donorMixRaw.find(function (d) {
+                  return d.type === "Returning Donors" || d.type === "Returning";
+                }) || {};
+                newDonorsCount = newDonorsObj.totalDonations || 0;
+                returningDonorsCount = returningDonorsObj.totalDonations || 0;
+                totalAmount = (newDonorsObj.totalAmount || 0) + (returningDonorsObj.totalAmount || 0);
+                totalCount = newDonorsCount + returningDonorsCount;
+                avgGift = totalCount > 0 ? Number((totalAmount / totalCount).toFixed(2)) : 0;
+              } else if (donorMixRaw && _typeof(donorMixRaw) === "object") {
+                newDonorsCount = donorMixRaw.newDonors || 0;
+                returningDonorsCount = donorMixRaw.returningDonors || 0;
+                avgGift = donorMixRaw.avgGift || 0;
+              }
+              activeCampaignRows = ((apiData === null || apiData === void 0 ? void 0 : apiData.activeCampaigns) || []).map(function (campaign) {
+                return [campaign.title || "Untitled Campaign", "$".concat(formatNumber(campaign.collectedAmount || 0)), "".concat(Math.round((campaign.collectedAmount || 0) / (campaign.usdTargetAmount || 1) * 100), "%"), "".concat(formatNumber(campaign.uniqueDonationsCount || 0)), "$".concat(formatNumber(campaign.avgGift || 0))];
+              });
+              trafficRows = ((apiData === null || apiData === void 0 || (_apiData$trafficSourc = apiData.trafficSourceData) === null || _apiData$trafficSourc === void 0 ? void 0 : _apiData$trafficSourc.data) || []).map(function (item) {
+                return [(item === null || item === void 0 ? void 0 : item.source) || (item === null || item === void 0 ? void 0 : item.name) || "-", "".concat(formatNumber((item === null || item === void 0 ? void 0 : item.donors) || (item === null || item === void 0 ? void 0 : item.totalDonors) || 0)), "$".concat(formatNumber((item === null || item === void 0 ? void 0 : item.revenue) || (item === null || item === void 0 ? void 0 : item.raised) || 0))];
+              });
+              donorMixRows = [["New donors", "".concat(formatNumber(newDonorsCount))], ["Returning donors", "".concat(formatNumber(returningDonorsCount))], ["Avg gift", "$".concat(formatNumber(avgGift))]];
+              refundsData = (apiData === null || apiData === void 0 ? void 0 : apiData.refundAndChargeBacks) || {};
+              totalRaised = Number((overview === null || overview === void 0 ? void 0 : overview.totalRevenue) || 0);
+              netRaised = Number((overview === null || overview === void 0 ? void 0 : overview.netRevenue) || 0);
+              totalDonors = Number((overview === null || overview === void 0 ? void 0 : overview.totalDonations) || 0);
+              convRate = Number((overview === null || overview === void 0 ? void 0 : overview.conversionRate) || 0);
+              avgDonation = Number((overview === null || overview === void 0 ? void 0 : overview.overallAVGDonations) || 0);
+              totalVisits = Number((apiData === null || apiData === void 0 ? void 0 : apiData.totalVisits) || 0);
+              passThrough = totalRaised > 0 ? "".concat((netRaised / totalRaised * 100).toFixed(1), "% pass-through") : "0% pass-through";
+              refundRate = Number((refundsData === null || refundsData === void 0 ? void 0 : refundsData.refundRate) || 0);
+              chargebackRate = Number((refundsData === null || refundsData === void 0 ? void 0 : refundsData.chargebackRate) || 0);
+              page1Cards = [{
+                title: "Total Raised",
+                value: "$".concat(formatNumber(totalRaised)),
+                trend: "".concat(fmtSigned(growth === null || growth === void 0 ? void 0 : growth.totalRevenue, "%"), " vs ").concat(dateLabel),
+                detail: "".concat(passThrough, " \xB7 ").concat(formatNumber(totalDonors), " donors \xB7 $").concat(formatNumber(avgDonation), " avg \xB7 ").concat(formatNumber(totalVisits), " visits")
+              }, {
+                title: "Net Raised",
+                value: "$".concat(formatNumber(netRaised)),
+                trend: fmtSigned(growth === null || growth === void 0 ? void 0 : growth.netRevenue, "%"),
+                detail: passThrough
+              }, {
+                title: "Total Donors",
+                value: "".concat(formatNumber(totalDonors)),
+                trend: fmtSigned(growth === null || growth === void 0 ? void 0 : growth.totalDonations, "%"),
+                detail: "".concat(formatNumber(newDonorsCount), " new \xB7 ").concat(formatNumber(returningDonorsCount), " returning")
+              }, {
+                title: "Avg Donation",
+                value: "$".concat(formatNumber(avgDonation)),
+                trend: fmtSigned(growth === null || growth === void 0 ? void 0 : growth.overallAVGDonations, "%"),
+                detail: "Median $".concat(formatNumber((apiData === null || apiData === void 0 ? void 0 : apiData.medianGift) || 0), " \xB7 top decile $").concat(formatNumber((apiData === null || apiData === void 0 ? void 0 : apiData.topDecileGift) || 0))
+              }, {
+                title: "ROAS",
+                value: "".concat(formatNumber((_apiData$roasCard = apiData === null || apiData === void 0 ? void 0 : apiData.roasCard) !== null && _apiData$roasCard !== void 0 ? _apiData$roasCard : 0), "x"),
+                trend: fmtSigned(apiData === null || apiData === void 0 ? void 0 : apiData.roasCardPrev, "x"),
+                detail: "$".concat(formatNumber((apiData === null || apiData === void 0 ? void 0 : apiData.adSpend) || 0), " spend \xB7 $").concat(formatNumber((apiData === null || apiData === void 0 ? void 0 : apiData.attributedRevenue) || 0), " attrib.")
+              }, {
+                title: "Conversion",
+                value: fmtPct(convRate, 1),
+                trend: fmtSigned(growth === null || growth === void 0 ? void 0 : growth.conversionRate, "pp"),
+                detail: "".concat(formatNumber(totalDonors), " from ").concat(formatNumber(totalVisits), " visits")
+              }, {
+                title: "Refund Rate",
+                value: fmtPct(refundRate, 2),
+                trend: fmtSigned(refundsData === null || refundsData === void 0 ? void 0 : refundsData.refundRateChange, "pp"),
+                detail: "".concat(formatNumber((refundsData === null || refundsData === void 0 ? void 0 : refundsData.refundCount) || 0), " refunds this period")
+              }];
+              addHeader();
+              y = 114;
+              page1Cards.forEach(function (card, idx) {
+                var col = idx % 3;
+                var row = Math.floor(idx / 3);
+                metricCard(_objectSpread2({
+                  x: marginX + col * (cardWidth + cardGap),
+                  y: y + row * (96 + 10)
+                }, card));
+              });
+              trendY = y + Math.ceil(page1Cards.length / 3) * (96 + 10) + 8;
+              doc.setDrawColor(229, 231, 235);
+              doc.roundedRect(marginX, trendY, contentWidth, 130, 6, 6);
+              doc.setFont("helvetica", "bold");
+              doc.setFontSize(12);
+              doc.setTextColor(17, 24, 39);
+              doc.text("Total revenue trend", marginX + 12, trendY + 20);
+              doc.setFont("helvetica", "normal");
+              doc.setFontSize(9.5);
+              doc.setTextColor(107, 114, 128);
+              doc.text("Last 30 days · daily aggregation", marginX + 12, trendY + 35);
+              doc.setFont("helvetica", "bold");
+              doc.setFontSize(14);
+              doc.setTextColor(17, 24, 39);
+              doc.text("$".concat(formatNumber(totalRaised)), marginX + 12, trendY + 58);
+              doc.setFont("helvetica", "normal");
+              doc.setFontSize(9.5);
+              doc.setTextColor(22, 163, 74);
+              doc.text("".concat(fmtSigned(growth === null || growth === void 0 ? void 0 : growth.totalRevenue, "%"), " vs ").concat(dateLabel), marginX + 110, trendY + 58);
+              autoTable(doc, {
+                startY: trendY + 68,
+                head: [["Channel", "Total"]],
+                body: [["Email", "$".concat(formatNumber((apiData === null || apiData === void 0 || (_apiData$overviewStat3 = apiData.overviewStats) === null || _apiData$overviewStat3 === void 0 || (_apiData$overviewStat3 = _apiData$overviewStat3.totalRaised) === null || _apiData$overviewStat3 === void 0 || (_apiData$overviewStat3 = _apiData$overviewStat3.email) === null || _apiData$overviewStat3 === void 0 || (_apiData$overviewStat4 = _apiData$overviewStat3.reduce) === null || _apiData$overviewStat4 === void 0 ? void 0 : _apiData$overviewStat4.call(_apiData$overviewStat3, function (s, i) {
+                  return s + ((i === null || i === void 0 ? void 0 : i.value) || 0);
+                }, 0)) || 0))], ["Organic", "$".concat(formatNumber((apiData === null || apiData === void 0 || (_apiData$overviewStat5 = apiData.overviewStats) === null || _apiData$overviewStat5 === void 0 || (_apiData$overviewStat5 = _apiData$overviewStat5.totalRaised) === null || _apiData$overviewStat5 === void 0 || (_apiData$overviewStat5 = _apiData$overviewStat5.organic) === null || _apiData$overviewStat5 === void 0 || (_apiData$overviewStat6 = _apiData$overviewStat5.reduce) === null || _apiData$overviewStat6 === void 0 ? void 0 : _apiData$overviewStat6.call(_apiData$overviewStat5, function (s, i) {
+                  return s + ((i === null || i === void 0 ? void 0 : i.value) || 0);
+                }, 0)) || 0))], ["Paid Ads", "$".concat(formatNumber((apiData === null || apiData === void 0 || (_apiData$overviewStat7 = apiData.overviewStats) === null || _apiData$overviewStat7 === void 0 || (_apiData$overviewStat7 = _apiData$overviewStat7.totalRaised) === null || _apiData$overviewStat7 === void 0 || (_apiData$overviewStat7 = _apiData$overviewStat7.paidAds) === null || _apiData$overviewStat7 === void 0 || (_apiData$overviewStat8 = _apiData$overviewStat7.reduce) === null || _apiData$overviewStat8 === void 0 ? void 0 : _apiData$overviewStat8.call(_apiData$overviewStat7, function (s, i) {
+                  return s + ((i === null || i === void 0 ? void 0 : i.value) || 0);
+                }, 0)) || 0))]],
+                margin: {
+                  left: marginX + 12,
+                  right: marginX + 12
+                },
+                styles: {
+                  fontSize: 9,
+                  cellPadding: 4
+                },
+                headStyles: {
+                  fillColor: [241, 245, 249],
+                  textColor: [51, 65, 85]
+                },
+                alternateRowStyles: {
+                  fillColor: [248, 250, 252]
+                }
+              });
+              addFooter(1, 2);
+              doc.addPage();
+              addHeader();
+              doc.setFont("helvetica", "bold");
+              doc.setFontSize(12);
+              doc.setTextColor(17, 24, 39);
+              doc.text("Active campaigns", marginX, 112);
+              doc.setFont("helvetica", "normal");
+              doc.setFontSize(9.5);
+              doc.setTextColor(107, 114, 128);
+              doc.text("Live fundraisers ranked by velocity", marginX, 126);
+              autoTable(doc, {
+                startY: 136,
+                head: [["CAMPAIGN", "RAISED", "PROGRESS", "DONORS", "AVG GIFT"]],
+                body: activeCampaignRows.length ? activeCampaignRows : [["-", "$0", "0%", "0", "$0"]],
+                margin: {
+                  left: marginX,
+                  right: marginX
+                },
+                styles: {
+                  fontSize: 9,
+                  cellPadding: 5
+                },
+                headStyles: {
+                  fillColor: [241, 245, 249],
+                  textColor: [51, 65, 85]
+                },
+                alternateRowStyles: {
+                  fillColor: [248, 250, 252]
+                }
+              });
+              donorCardTop = (((_doc$lastAutoTable = doc.lastAutoTable) === null || _doc$lastAutoTable === void 0 ? void 0 : _doc$lastAutoTable.finalY) || 230) + 14;
+              doc.setDrawColor(229, 231, 235);
+              doc.roundedRect(marginX, donorCardTop, 250, 108, 6, 6);
+              doc.setFont("helvetica", "bold");
+              doc.setFontSize(11);
+              doc.setTextColor(17, 24, 39);
+              doc.text("Donor mix", marginX + 10, donorCardTop + 18);
+              doc.setFont("helvetica", "normal");
+              doc.setFontSize(9);
+              doc.setTextColor(107, 114, 128);
+              doc.text("Acquisition vs retention", marginX + 10, donorCardTop + 32);
+              autoTable(doc, {
+                startY: donorCardTop + 38,
+                head: [["Type", "Value"]],
+                body: donorMixRows,
+                margin: {
+                  left: marginX + 10,
+                  right: pageWidth - (marginX + 240)
+                },
+                styles: {
+                  fontSize: 9,
+                  cellPadding: 4
+                },
+                headStyles: {
+                  fillColor: [241, 245, 249],
+                  textColor: [51, 65, 85]
+                }
+              });
+              autoTable(doc, {
+                startY: donorCardTop,
+                head: [["SOURCE", "DONORS", "REVENUE"]],
+                body: trafficRows.length > 0 ? trafficRows : [["-", "0", "$0"]],
+                margin: {
+                  left: marginX + 266,
+                  right: marginX
+                },
+                styles: {
+                  fontSize: 9,
+                  cellPadding: 5
+                },
+                headStyles: {
+                  fillColor: [241, 245, 249],
+                  textColor: [51, 65, 85]
+                },
+                alternateRowStyles: {
+                  fillColor: [248, 250, 252]
+                }
+              });
+              miscRows = [["Refunds", "".concat(formatNumber(refundRate), "%")], ["Chargebacks", "".concat(formatNumber(chargebackRate), "%")], ["Order Bump", "$".concat(formatNumber((apiData === null || apiData === void 0 || (_apiData$orderBumpDet = apiData.orderBumpDetails) === null || _apiData$orderBumpDet === void 0 ? void 0 : _apiData$orderBumpDet.totalRevenue) || 0))], ["Upsell Raised", "$".concat(formatNumber((apiData === null || apiData === void 0 || (_apiData$upSellDetail = apiData.upSellDetails) === null || _apiData$upSellDetail === void 0 ? void 0 : _apiData$upSellDetail.raised) || 0))], ["Downsell Raised", "$".concat(formatNumber((apiData === null || apiData === void 0 || (_apiData$downSellDeta = apiData.downSellDetails) === null || _apiData$downSellDeta === void 0 ? void 0 : _apiData$downSellDeta.raised) || 0))], ["Referrals", "$".concat(formatNumber((apiData === null || apiData === void 0 || (_apiData$referralDeta = apiData.referralDetails) === null || _apiData$referralDeta === void 0 ? void 0 : _apiData$referralDeta.totalRevenue) || 0))]];
+              autoTable(doc, {
+                startY: (((_doc$lastAutoTable2 = doc.lastAutoTable) === null || _doc$lastAutoTable2 === void 0 ? void 0 : _doc$lastAutoTable2.finalY) || donorCardTop + 120) + 12,
+                head: [["Additional Blocks", "Value"]],
+                body: miscRows,
+                margin: {
+                  left: marginX,
+                  right: marginX
+                },
+                styles: {
+                  fontSize: 9,
+                  cellPadding: 5
+                },
+                headStyles: {
+                  fillColor: [241, 245, 249],
+                  textColor: [51, 65, 85]
+                },
+                alternateRowStyles: {
+                  fillColor: [248, 250, 252]
+                }
+              });
+              addFooter(2, 2);
+              safeDate = new Date().toISOString().slice(0, 10);
+              doc.save("DashboardOverview_report_".concat(safeDate, ".pdf"));
+              _context.n = 3;
+              break;
+            case 2:
+              _context.p = 2;
+              _t = _context.v;
+              // Keep console message for host app debugging when export dependency is missing.
+              console.error("Failed to export overall dashboard PDF:", _t);
+            case 3:
+              return _context.a(2);
+          }
+        }, _callee, null, [[0, 2]]);
+      }));
+      return function buildAndDownloadPdf() {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+    buildAndDownloadPdf();
   }, [exportTrigger]);
   var currentData = metric === "Revenue" ? revenueData : donationsData;
   var oneTimeData = (apiData === null || apiData === void 0 ? void 0 : apiData.oneTimeDonations) || [];
@@ -1641,7 +2129,7 @@ var UTMPerformance = function UTMPerformance() {
         type: "line",
         height: 320
       }), /*#__PURE__*/jsx(TableContainer, {
-        children: /*#__PURE__*/jsxs(Table, {
+        children: /*#__PURE__*/jsxs(Table$1, {
           sx: {
             borderCollapse: "collapse"
           },
@@ -2191,7 +2679,7 @@ var AbandonedDonationRecovery = function AbandonedDonationRecovery() {
         sx: {
           px: "25px"
         },
-        children: /*#__PURE__*/jsxs(Table, {
+        children: /*#__PURE__*/jsxs(Table$1, {
           sx: {
             borderCollapse: "separate",
             borderSpacing: 0,
@@ -3032,19 +3520,6 @@ var DonorMixCard = function DonorMixCard(_ref) {
   });
 };
 
-function formatNumber(num) {
-  if (num >= 1000000000) {
-    return (num / 1000000000).toFixed(1).replace(/\.0$/, "") + "B";
-  }
-  if (num >= 1000000) {
-    return (num / 1000000).toFixed(1).replace(/\.0$/, "") + "M";
-  }
-  if (num >= 1000) {
-    return (num / 1000).toFixed(1).replace(/\.0$/, "") + "K";
-  }
-  return (num !== null && num !== void 0 ? num : 0).toString();
-}
-
 var TrafficSourceCard = function TrafficSourceCard(_ref) {
   var _ref$title = _ref.title,
     title = _ref$title === void 0 ? "Traffic source" : _ref$title,
@@ -6963,5 +7438,2105 @@ var EmailSection$1 = /*#__PURE__*/Object.freeze({
   default: EmailSection
 });
 
+/**
+ * Improved text function with halign and valign support
+ * Inspiration from: http://stackoverflow.com/questions/28327510/align-text-right-using-jspdf/28433113#28433113
+ */
+function autoTableText (text, x, y, styles, doc) {
+    styles = styles || {};
+    var PHYSICAL_LINE_HEIGHT = 1.15;
+    var k = doc.internal.scaleFactor;
+    var fontSize = doc.internal.getFontSize() / k;
+    var lineHeightFactor = doc.getLineHeightFactor
+        ? doc.getLineHeightFactor()
+        : PHYSICAL_LINE_HEIGHT;
+    var lineHeight = fontSize * lineHeightFactor;
+    var splitRegex = /\r\n|\r|\n/g;
+    var splitText = '';
+    var lineCount = 1;
+    if (styles.valign === 'middle' ||
+        styles.valign === 'bottom' ||
+        styles.halign === 'center' ||
+        styles.halign === 'right') {
+        splitText = typeof text === 'string' ? text.split(splitRegex) : text;
+        lineCount = splitText.length || 1;
+    }
+    // Align the top
+    y += fontSize * (2 - PHYSICAL_LINE_HEIGHT);
+    if (styles.valign === 'middle')
+        y -= (lineCount / 2) * lineHeight;
+    else if (styles.valign === 'bottom')
+        y -= lineCount * lineHeight;
+    if (styles.halign === 'center' || styles.halign === 'right') {
+        var alignSize = fontSize;
+        if (styles.halign === 'center')
+            alignSize *= 0.5;
+        if (splitText && lineCount >= 1) {
+            for (var iLine = 0; iLine < splitText.length; iLine++) {
+                doc.text(splitText[iLine], x - doc.getStringUnitWidth(splitText[iLine]) * alignSize, y);
+                y += lineHeight;
+            }
+            return doc;
+        }
+        x -= doc.getStringUnitWidth(text) * alignSize;
+    }
+    if (styles.halign === 'justify') {
+        doc.text(text, x, y, { maxWidth: styles.maxWidth || 100, align: 'justify' });
+    }
+    else {
+        doc.text(text, x, y);
+    }
+    return doc;
+}
+
+var globalDefaults = {};
+var DocHandler = /** @class */ (function () {
+    function DocHandler(jsPDFDocument) {
+        this.jsPDFDocument = jsPDFDocument;
+        this.userStyles = {
+            // Black for versions of jspdf without getTextColor
+            textColor: jsPDFDocument.getTextColor
+                ? this.jsPDFDocument.getTextColor()
+                : 0,
+            fontSize: jsPDFDocument.internal.getFontSize(),
+            fontStyle: jsPDFDocument.internal.getFont().fontStyle,
+            font: jsPDFDocument.internal.getFont().fontName,
+            // 0 for versions of jspdf without getLineWidth
+            lineWidth: jsPDFDocument.getLineWidth
+                ? this.jsPDFDocument.getLineWidth()
+                : 0,
+            // Black for versions of jspdf without getDrawColor
+            lineColor: jsPDFDocument.getDrawColor
+                ? this.jsPDFDocument.getDrawColor()
+                : 0,
+        };
+    }
+    DocHandler.setDefaults = function (defaults, doc) {
+        if (doc === void 0) { doc = null; }
+        if (doc) {
+            doc.__autoTableDocumentDefaults = defaults;
+        }
+        else {
+            globalDefaults = defaults;
+        }
+    };
+    DocHandler.unifyColor = function (c) {
+        if (Array.isArray(c)) {
+            return c;
+        }
+        else if (typeof c === 'number') {
+            return [c, c, c];
+        }
+        else if (typeof c === 'string') {
+            return [c];
+        }
+        else {
+            return null;
+        }
+    };
+    DocHandler.prototype.applyStyles = function (styles, fontOnly) {
+        // Font style needs to be applied before font
+        // https://github.com/simonbengtsson/jsPDF-AutoTable/issues/632
+        var _a, _b, _c;
+        if (fontOnly === void 0) { fontOnly = false; }
+        if (styles.fontStyle && this.jsPDFDocument.setFontStyle) {
+            this.jsPDFDocument.setFontStyle(styles.fontStyle);
+        }
+        var _d = this.jsPDFDocument.internal.getFont(), fontStyle = _d.fontStyle, fontName = _d.fontName;
+        if (styles.font)
+            fontName = styles.font;
+        if (styles.fontStyle) {
+            fontStyle = styles.fontStyle;
+            var availableFontStyles = this.getFontList()[fontName];
+            if (availableFontStyles &&
+                availableFontStyles.indexOf(fontStyle) === -1 &&
+                this.jsPDFDocument.setFontStyle) {
+                // Common issue was that the default bold in headers
+                // made custom fonts not work. For example:
+                // https://github.com/simonbengtsson/jsPDF-AutoTable/issues/653
+                this.jsPDFDocument.setFontStyle(availableFontStyles[0]);
+                fontStyle = availableFontStyles[0];
+            }
+        }
+        this.jsPDFDocument.setFont(fontName, fontStyle);
+        if (styles.fontSize)
+            this.jsPDFDocument.setFontSize(styles.fontSize);
+        if (fontOnly) {
+            return; // Performance improvement
+        }
+        var color = DocHandler.unifyColor(styles.fillColor);
+        if (color)
+            (_a = this.jsPDFDocument).setFillColor.apply(_a, color);
+        color = DocHandler.unifyColor(styles.textColor);
+        if (color)
+            (_b = this.jsPDFDocument).setTextColor.apply(_b, color);
+        color = DocHandler.unifyColor(styles.lineColor);
+        if (color)
+            (_c = this.jsPDFDocument).setDrawColor.apply(_c, color);
+        if (typeof styles.lineWidth === 'number') {
+            this.jsPDFDocument.setLineWidth(styles.lineWidth);
+        }
+    };
+    DocHandler.prototype.splitTextToSize = function (text, size, opts) {
+        return this.jsPDFDocument.splitTextToSize(text, size, opts);
+    };
+    /**
+     * Adds a rectangle to the PDF
+     * @param x Coordinate (in units declared at inception of PDF document) against left edge of the page
+     * @param y Coordinate (in units declared at inception of PDF document) against upper edge of the page
+     * @param width Width (in units declared at inception of PDF document)
+     * @param height Height (in units declared at inception of PDF document)
+     * @param fillStyle A string specifying the painting style or null. Valid styles include: 'S' [default] - stroke, 'F' - fill, and 'DF' (or 'FD') - fill then stroke.
+     */
+    DocHandler.prototype.rect = function (x, y, width, height, fillStyle) {
+        // null is excluded from fillStyle possible values because it isn't needed
+        // and is prone to bugs as it's used to postpone setting the style
+        // https://rawgit.com/MrRio/jsPDF/master/docs/jsPDF.html#rect
+        return this.jsPDFDocument.rect(x, y, width, height, fillStyle);
+    };
+    DocHandler.prototype.getLastAutoTable = function () {
+        return this.jsPDFDocument.lastAutoTable || null;
+    };
+    DocHandler.prototype.getTextWidth = function (text) {
+        return this.jsPDFDocument.getTextWidth(text);
+    };
+    DocHandler.prototype.getDocument = function () {
+        return this.jsPDFDocument;
+    };
+    DocHandler.prototype.setPage = function (page) {
+        this.jsPDFDocument.setPage(page);
+    };
+    DocHandler.prototype.addPage = function () {
+        return this.jsPDFDocument.addPage();
+    };
+    DocHandler.prototype.getFontList = function () {
+        return this.jsPDFDocument.getFontList();
+    };
+    DocHandler.prototype.getGlobalOptions = function () {
+        return globalDefaults || {};
+    };
+    DocHandler.prototype.getDocumentOptions = function () {
+        return this.jsPDFDocument.__autoTableDocumentDefaults || {};
+    };
+    DocHandler.prototype.pageSize = function () {
+        var pageSize = this.jsPDFDocument.internal.pageSize;
+        // JSPDF 1.4 uses get functions instead of properties on pageSize
+        if (pageSize.width == null) {
+            pageSize = { width: pageSize.getWidth(), height: pageSize.getHeight() };
+        }
+        return pageSize;
+    };
+    DocHandler.prototype.scaleFactor = function () {
+        return this.jsPDFDocument.internal.scaleFactor;
+    };
+    DocHandler.prototype.getLineHeightFactor = function () {
+        var doc = this.jsPDFDocument;
+        return doc.getLineHeightFactor ? doc.getLineHeightFactor() : 1.15;
+    };
+    DocHandler.prototype.getLineHeight = function (fontSize) {
+        return (fontSize / this.scaleFactor()) * this.getLineHeightFactor();
+    };
+    DocHandler.prototype.pageNumber = function () {
+        var pageInfo = this.jsPDFDocument.internal.getCurrentPageInfo();
+        if (!pageInfo) {
+            // Only recent versions of jspdf has pageInfo
+            return this.jsPDFDocument.internal.getNumberOfPages();
+        }
+        return pageInfo.pageNumber;
+    };
+    return DocHandler;
+}());
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var HtmlRowInput = /** @class */ (function (_super) {
+    __extends(HtmlRowInput, _super);
+    function HtmlRowInput(element) {
+        var _this = _super.call(this) || this;
+        _this._element = element;
+        return _this;
+    }
+    return HtmlRowInput;
+}(Array));
+// Base style for all themes
+function defaultStyles(scaleFactor) {
+    return {
+        font: 'helvetica', // helvetica, times, courier
+        fontStyle: 'normal', // normal, bold, italic, bolditalic
+        overflow: 'linebreak', // linebreak, ellipsize, visible or hidden
+        fillColor: false, // Either false for transparent, rbg array e.g. [255, 255, 255] or gray level e.g 200
+        textColor: 20,
+        halign: 'left', // left, center, right, justify
+        valign: 'top', // top, middle, bottom
+        fontSize: 10,
+        cellPadding: 5 / scaleFactor, // number or {top,left,right,left,vertical,horizontal}
+        lineColor: 200,
+        lineWidth: 0,
+        cellWidth: 'auto', // 'auto'|'wrap'|number
+        minCellHeight: 0,
+        minCellWidth: 0,
+    };
+}
+function getTheme(name) {
+    var themes = {
+        striped: {
+            table: { fillColor: 255, textColor: 80, fontStyle: 'normal' },
+            head: { textColor: 255, fillColor: [41, 128, 185], fontStyle: 'bold' },
+            body: {},
+            foot: { textColor: 255, fillColor: [41, 128, 185], fontStyle: 'bold' },
+            alternateRow: { fillColor: 245 },
+        },
+        grid: {
+            table: {
+                fillColor: 255,
+                textColor: 80,
+                fontStyle: 'normal',
+                lineWidth: 0.1,
+            },
+            head: {
+                textColor: 255,
+                fillColor: [26, 188, 156],
+                fontStyle: 'bold',
+                lineWidth: 0,
+            },
+            body: {},
+            foot: {
+                textColor: 255,
+                fillColor: [26, 188, 156],
+                fontStyle: 'bold',
+                lineWidth: 0,
+            },
+            alternateRow: {},
+        },
+        plain: { head: { fontStyle: 'bold' }, foot: { fontStyle: 'bold' } },
+    };
+    return themes[name];
+}
+
+function getStringWidth(text, styles, doc) {
+    doc.applyStyles(styles, true);
+    var textArr = Array.isArray(text) ? text : [text];
+    var widestLineWidth = textArr
+        .map(function (text) { return doc.getTextWidth(text); })
+        .reduce(function (a, b) { return Math.max(a, b); }, 0);
+    return widestLineWidth;
+}
+function addTableBorder(doc, table, startPos, cursor) {
+    var lineWidth = table.settings.tableLineWidth;
+    var lineColor = table.settings.tableLineColor;
+    doc.applyStyles({ lineWidth: lineWidth, lineColor: lineColor });
+    var fillStyle = getFillStyle(lineWidth, false);
+    if (fillStyle) {
+        doc.rect(startPos.x, startPos.y, table.getWidth(doc.pageSize().width), cursor.y - startPos.y, fillStyle);
+    }
+}
+function getFillStyle(lineWidth, fillColor) {
+    var drawLine = lineWidth > 0;
+    var drawBackground = fillColor || fillColor === 0;
+    if (drawLine && drawBackground) {
+        return 'DF'; // Fill then stroke
+    }
+    else if (drawLine) {
+        return 'S'; // Only stroke (transparent background)
+    }
+    else if (drawBackground) {
+        return 'F'; // Only fill, no stroke
+    }
+    else {
+        return null;
+    }
+}
+function parseSpacing(value, defaultValue) {
+    var _a, _b, _c, _d;
+    value = value || defaultValue;
+    if (Array.isArray(value)) {
+        if (value.length >= 4) {
+            return {
+                top: value[0],
+                right: value[1],
+                bottom: value[2],
+                left: value[3],
+            };
+        }
+        else if (value.length === 3) {
+            return {
+                top: value[0],
+                right: value[1],
+                bottom: value[2],
+                left: value[1],
+            };
+        }
+        else if (value.length === 2) {
+            return {
+                top: value[0],
+                right: value[1],
+                bottom: value[0],
+                left: value[1],
+            };
+        }
+        else if (value.length === 1) {
+            value = value[0];
+        }
+        else {
+            value = defaultValue;
+        }
+    }
+    if (typeof value === 'object') {
+        if (typeof value.vertical === 'number') {
+            value.top = value.vertical;
+            value.bottom = value.vertical;
+        }
+        if (typeof value.horizontal === 'number') {
+            value.right = value.horizontal;
+            value.left = value.horizontal;
+        }
+        return {
+            left: (_a = value.left) !== null && _a !== void 0 ? _a : defaultValue,
+            top: (_b = value.top) !== null && _b !== void 0 ? _b : defaultValue,
+            right: (_c = value.right) !== null && _c !== void 0 ? _c : defaultValue,
+            bottom: (_d = value.bottom) !== null && _d !== void 0 ? _d : defaultValue,
+        };
+    }
+    if (typeof value !== 'number') {
+        value = defaultValue;
+    }
+    return { top: value, right: value, bottom: value, left: value };
+}
+function getPageAvailableWidth(doc, table) {
+    var margins = parseSpacing(table.settings.margin, 0);
+    return doc.pageSize().width - (margins.left + margins.right);
+}
+
+// Limitations
+// - No support for border spacing
+// - No support for transparency
+function parseCss(supportedFonts, element, scaleFactor, style, window) {
+    var result = {};
+    var pxScaleFactor = 96 / 72;
+    var backgroundColor = parseColor(element, function (elem) {
+        return window.getComputedStyle(elem)['backgroundColor'];
+    });
+    if (backgroundColor != null)
+        result.fillColor = backgroundColor;
+    var textColor = parseColor(element, function (elem) {
+        return window.getComputedStyle(elem)['color'];
+    });
+    if (textColor != null)
+        result.textColor = textColor;
+    var padding = parsePadding(style, scaleFactor);
+    if (padding)
+        result.cellPadding = padding;
+    var borderColorSide = 'borderTopColor';
+    var finalScaleFactor = pxScaleFactor * scaleFactor;
+    var btw = style.borderTopWidth;
+    if (style.borderBottomWidth === btw &&
+        style.borderRightWidth === btw &&
+        style.borderLeftWidth === btw) {
+        var borderWidth = (parseFloat(btw) || 0) / finalScaleFactor;
+        if (borderWidth)
+            result.lineWidth = borderWidth;
+    }
+    else {
+        result.lineWidth = {
+            top: (parseFloat(style.borderTopWidth) || 0) / finalScaleFactor,
+            right: (parseFloat(style.borderRightWidth) || 0) / finalScaleFactor,
+            bottom: (parseFloat(style.borderBottomWidth) || 0) / finalScaleFactor,
+            left: (parseFloat(style.borderLeftWidth) || 0) / finalScaleFactor,
+        };
+        // Choose border color of first available side
+        // could be improved by supporting object as lineColor
+        if (!result.lineWidth.top) {
+            if (result.lineWidth.right) {
+                borderColorSide = 'borderRightColor';
+            }
+            else if (result.lineWidth.bottom) {
+                borderColorSide = 'borderBottomColor';
+            }
+            else if (result.lineWidth.left) {
+                borderColorSide = 'borderLeftColor';
+            }
+        }
+    }
+    var borderColor = parseColor(element, function (elem) {
+        return window.getComputedStyle(elem)[borderColorSide];
+    });
+    if (borderColor != null)
+        result.lineColor = borderColor;
+    var accepted = ['left', 'right', 'center', 'justify'];
+    if (accepted.indexOf(style.textAlign) !== -1) {
+        result.halign = style.textAlign;
+    }
+    accepted = ['middle', 'bottom', 'top'];
+    if (accepted.indexOf(style.verticalAlign) !== -1) {
+        result.valign = style.verticalAlign;
+    }
+    var res = parseInt(style.fontSize || '');
+    if (!isNaN(res))
+        result.fontSize = res / pxScaleFactor;
+    var fontStyle = parseFontStyle(style);
+    if (fontStyle)
+        result.fontStyle = fontStyle;
+    var font = (style.fontFamily || '').toLowerCase();
+    if (supportedFonts.indexOf(font) !== -1) {
+        result.font = font;
+    }
+    return result;
+}
+function parseFontStyle(style) {
+    var res = '';
+    if (style.fontWeight === 'bold' ||
+        style.fontWeight === 'bolder' ||
+        parseInt(style.fontWeight) >= 700) {
+        res = 'bold';
+    }
+    if (style.fontStyle === 'italic' || style.fontStyle === 'oblique') {
+        res += 'italic';
+    }
+    return res;
+}
+function parseColor(element, styleGetter) {
+    var cssColor = realColor(element, styleGetter);
+    if (!cssColor)
+        return null;
+    var rgba = cssColor.match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d*\.?\d*))?\)$/);
+    if (!rgba || !Array.isArray(rgba)) {
+        return null;
+    }
+    var color = [
+        parseInt(rgba[1]),
+        parseInt(rgba[2]),
+        parseInt(rgba[3]),
+    ];
+    var alpha = parseInt(rgba[4]);
+    if (alpha === 0 || isNaN(color[0]) || isNaN(color[1]) || isNaN(color[2])) {
+        return null;
+    }
+    return color;
+}
+function realColor(elem, styleGetter) {
+    var bg = styleGetter(elem);
+    if (bg === 'rgba(0, 0, 0, 0)' ||
+        bg === 'transparent' ||
+        bg === 'initial' ||
+        bg === 'inherit') {
+        if (elem.parentElement == null) {
+            return null;
+        }
+        return realColor(elem.parentElement, styleGetter);
+    }
+    else {
+        return bg;
+    }
+}
+function parsePadding(style, scaleFactor) {
+    var val = [
+        style.paddingTop,
+        style.paddingRight,
+        style.paddingBottom,
+        style.paddingLeft,
+    ];
+    var pxScaleFactor = 96 / (72 / scaleFactor);
+    var linePadding = (parseInt(style.lineHeight) - parseInt(style.fontSize)) / scaleFactor / 2;
+    var inputPadding = val.map(function (n) {
+        return parseInt(n || '0') / pxScaleFactor;
+    });
+    var padding = parseSpacing(inputPadding, 0);
+    if (linePadding > padding.top) {
+        padding.top = linePadding;
+    }
+    if (linePadding > padding.bottom) {
+        padding.bottom = linePadding;
+    }
+    return padding;
+}
+
+function parseHtml(doc, input, window, includeHiddenHtml, useCss) {
+    var _a, _b;
+    if (includeHiddenHtml === void 0) { includeHiddenHtml = false; }
+    if (useCss === void 0) { useCss = false; }
+    var tableElement;
+    if (typeof input === 'string') {
+        tableElement = window.document.querySelector(input);
+    }
+    else {
+        tableElement = input;
+    }
+    var supportedFonts = Object.keys(doc.getFontList());
+    var scaleFactor = doc.scaleFactor();
+    var head = [], body = [], foot = [];
+    if (!tableElement) {
+        console.error('Html table could not be found with input: ', input);
+        return { head: head, body: body, foot: foot };
+    }
+    for (var i = 0; i < tableElement.rows.length; i++) {
+        var element = tableElement.rows[i];
+        var tagName = (_b = (_a = element === null || element === void 0 ? void 0 : element.parentElement) === null || _a === void 0 ? void 0 : _a.tagName) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+        var row = parseRowContent(supportedFonts, scaleFactor, window, element, includeHiddenHtml, useCss);
+        if (!row)
+            continue;
+        if (tagName === 'thead') {
+            head.push(row);
+        }
+        else if (tagName === 'tfoot') {
+            foot.push(row);
+        }
+        else {
+            // Add to body both if parent is tbody or table
+            body.push(row);
+        }
+    }
+    return { head: head, body: body, foot: foot };
+}
+function parseRowContent(supportedFonts, scaleFactor, window, row, includeHidden, useCss) {
+    var resultRow = new HtmlRowInput(row);
+    for (var i = 0; i < row.cells.length; i++) {
+        var cell = row.cells[i];
+        var style_1 = window.getComputedStyle(cell);
+        if (includeHidden || style_1.display !== 'none') {
+            var cellStyles = void 0;
+            if (useCss) {
+                cellStyles = parseCss(supportedFonts, cell, scaleFactor, style_1, window);
+            }
+            resultRow.push({
+                rowSpan: cell.rowSpan,
+                colSpan: cell.colSpan,
+                styles: cellStyles,
+                _element: cell,
+                content: parseCellContent(cell),
+            });
+        }
+    }
+    var style = window.getComputedStyle(row);
+    if (resultRow.length > 0 && (includeHidden || style.display !== 'none')) {
+        return resultRow;
+    }
+}
+function parseCellContent(orgCell) {
+    // Work on cloned node to make sure no changes are applied to html table
+    var cell = orgCell.cloneNode(true);
+    // Remove extra space and line breaks in markup to make it more similar to
+    // what would be shown in html
+    cell.innerHTML = cell.innerHTML.replace(/\n/g, '').replace(/ +/g, ' ');
+    // Preserve <br> tags as line breaks in the pdf
+    cell.innerHTML = cell.innerHTML
+        .split(/<br.*?>/) //start with '<br' and ends with '>'.
+        .map(function (part) { return part.trim(); })
+        .join('\n');
+    // innerText for ie
+    return cell.innerText || cell.textContent || '';
+}
+
+function validateInput(global, document, current) {
+    for (var _i = 0, _a = [global, document, current]; _i < _a.length; _i++) {
+        var options = _a[_i];
+        if (options && typeof options !== 'object') {
+            console.error('The options parameter should be of type object, is: ' + typeof options);
+        }
+        if (options.startY && typeof options.startY !== 'number') {
+            console.error('Invalid value for startY option', options.startY);
+            delete options.startY;
+        }
+    }
+}
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+function assign(target, s, s1, s2, s3) {
+    if (target == null) {
+        throw new TypeError('Cannot convert undefined or null to object');
+    }
+    var to = Object(target);
+    for (var index = 1; index < arguments.length; index++) {
+        // eslint-disable-next-line prefer-rest-params
+        var nextSource = arguments[index];
+        if (nextSource != null) {
+            // Skip over if undefined or null
+            for (var nextKey in nextSource) {
+                // Avoid bugs when hasOwnProperty is shadowed
+                if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+                    to[nextKey] = nextSource[nextKey];
+                }
+            }
+        }
+    }
+    return to;
+}
+
+function parseInput(d, current) {
+    var doc = new DocHandler(d);
+    var document = doc.getDocumentOptions();
+    var global = doc.getGlobalOptions();
+    validateInput(global, document, current);
+    var options = assign({}, global, document, current);
+    var win;
+    if (typeof window !== 'undefined') {
+        win = window;
+    }
+    var styles = parseStyles(global, document, current);
+    var hooks = parseHooks(global, document, current);
+    var settings = parseSettings(doc, options);
+    var content = parseContent$1(doc, options, win);
+    return { id: current.tableId, content: content, hooks: hooks, styles: styles, settings: settings };
+}
+function parseStyles(gInput, dInput, cInput) {
+    var styleOptions = {
+        styles: {},
+        headStyles: {},
+        bodyStyles: {},
+        footStyles: {},
+        alternateRowStyles: {},
+        columnStyles: {},
+    };
+    var _loop_1 = function (prop) {
+        if (prop === 'columnStyles') {
+            var global = gInput[prop];
+            var document_1 = dInput[prop];
+            var current = cInput[prop];
+            styleOptions.columnStyles = assign({}, global, document_1, current);
+        }
+        else {
+            var allOptions = [gInput, dInput, cInput];
+            var styles = allOptions.map(function (opts) { return opts[prop] || {}; });
+            styleOptions[prop] = assign({}, styles[0], styles[1], styles[2]);
+        }
+    };
+    for (var _i = 0, _a = Object.keys(styleOptions); _i < _a.length; _i++) {
+        var prop = _a[_i];
+        _loop_1(prop);
+    }
+    return styleOptions;
+}
+function parseHooks(global, document, current) {
+    var allOptions = [global, document, current];
+    var result = {
+        didParseCell: [],
+        willDrawCell: [],
+        didDrawCell: [],
+        willDrawPage: [],
+        didDrawPage: [],
+    };
+    for (var _i = 0, allOptions_1 = allOptions; _i < allOptions_1.length; _i++) {
+        var options = allOptions_1[_i];
+        if (options.didParseCell)
+            result.didParseCell.push(options.didParseCell);
+        if (options.willDrawCell)
+            result.willDrawCell.push(options.willDrawCell);
+        if (options.didDrawCell)
+            result.didDrawCell.push(options.didDrawCell);
+        if (options.willDrawPage)
+            result.willDrawPage.push(options.willDrawPage);
+        if (options.didDrawPage)
+            result.didDrawPage.push(options.didDrawPage);
+    }
+    return result;
+}
+function parseSettings(doc, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    var margin = parseSpacing(options.margin, 40 / doc.scaleFactor());
+    var startY = (_a = getStartY(doc, options.startY)) !== null && _a !== void 0 ? _a : margin.top;
+    var showFoot;
+    if (options.showFoot === true) {
+        showFoot = 'everyPage';
+    }
+    else if (options.showFoot === false) {
+        showFoot = 'never';
+    }
+    else {
+        showFoot = (_b = options.showFoot) !== null && _b !== void 0 ? _b : 'everyPage';
+    }
+    var showHead;
+    if (options.showHead === true) {
+        showHead = 'everyPage';
+    }
+    else if (options.showHead === false) {
+        showHead = 'never';
+    }
+    else {
+        showHead = (_c = options.showHead) !== null && _c !== void 0 ? _c : 'everyPage';
+    }
+    var useCss = (_d = options.useCss) !== null && _d !== void 0 ? _d : false;
+    var theme = options.theme || (useCss ? 'plain' : 'striped');
+    var horizontalPageBreak = !!options.horizontalPageBreak;
+    var horizontalPageBreakRepeat = (_e = options.horizontalPageBreakRepeat) !== null && _e !== void 0 ? _e : null;
+    return {
+        includeHiddenHtml: (_f = options.includeHiddenHtml) !== null && _f !== void 0 ? _f : false,
+        useCss: useCss,
+        theme: theme,
+        startY: startY,
+        margin: margin,
+        pageBreak: (_g = options.pageBreak) !== null && _g !== void 0 ? _g : 'auto',
+        rowPageBreak: (_h = options.rowPageBreak) !== null && _h !== void 0 ? _h : 'auto',
+        tableWidth: (_j = options.tableWidth) !== null && _j !== void 0 ? _j : 'auto',
+        showHead: showHead,
+        showFoot: showFoot,
+        tableLineWidth: (_k = options.tableLineWidth) !== null && _k !== void 0 ? _k : 0,
+        tableLineColor: (_l = options.tableLineColor) !== null && _l !== void 0 ? _l : 200,
+        horizontalPageBreak: horizontalPageBreak,
+        horizontalPageBreakRepeat: horizontalPageBreakRepeat,
+        horizontalPageBreakBehaviour: (_m = options.horizontalPageBreakBehaviour) !== null && _m !== void 0 ? _m : 'afterAllRows',
+    };
+}
+function getStartY(doc, userStartY) {
+    var previous = doc.getLastAutoTable();
+    var sf = doc.scaleFactor();
+    var currentPage = doc.pageNumber();
+    var isSamePageAsPreviousTable = false;
+    if (previous && previous.startPageNumber) {
+        var endingPage = previous.startPageNumber + previous.pageNumber - 1;
+        isSamePageAsPreviousTable = endingPage === currentPage;
+    }
+    if (typeof userStartY === 'number') {
+        return userStartY;
+    }
+    else if (userStartY == null || userStartY === false) {
+        if (isSamePageAsPreviousTable && (previous === null || previous === void 0 ? void 0 : previous.finalY) != null) {
+            // Some users had issues with overlapping tables when they used multiple
+            // tables without setting startY so setting it here to a sensible default.
+            return previous.finalY + 20 / sf;
+        }
+    }
+    return null;
+}
+function parseContent$1(doc, options, window) {
+    var head = options.head || [];
+    var body = options.body || [];
+    var foot = options.foot || [];
+    if (options.html) {
+        var hidden = options.includeHiddenHtml;
+        if (window) {
+            var htmlContent = parseHtml(doc, options.html, window, hidden, options.useCss) || {};
+            head = htmlContent.head || head;
+            body = htmlContent.body || head;
+            foot = htmlContent.foot || head;
+        }
+        else {
+            console.error('Cannot parse html in non browser environment');
+        }
+    }
+    var columns = options.columns || parseColumns(head, body, foot);
+    return { columns: columns, head: head, body: body, foot: foot };
+}
+function parseColumns(head, body, foot) {
+    var firstRow = head[0] || body[0] || foot[0] || [];
+    var result = [];
+    Object.keys(firstRow)
+        .filter(function (key) { return key !== '_element'; })
+        .forEach(function (key) {
+        var colSpan = 1;
+        var input;
+        if (Array.isArray(firstRow)) {
+            input = firstRow[parseInt(key)];
+        }
+        else {
+            input = firstRow[key];
+        }
+        if (typeof input === 'object' && !Array.isArray(input)) {
+            colSpan = (input === null || input === void 0 ? void 0 : input.colSpan) || 1;
+        }
+        for (var i = 0; i < colSpan; i++) {
+            var id = void 0;
+            if (Array.isArray(firstRow)) {
+                id = result.length;
+            }
+            else {
+                id = key + (i > 0 ? "_".concat(i) : '');
+            }
+            var rowResult = { dataKey: id };
+            result.push(rowResult);
+        }
+    });
+    return result;
+}
+
+var HookData = /** @class */ (function () {
+    function HookData(doc, table, cursor) {
+        this.table = table;
+        this.pageNumber = table.pageNumber;
+        this.settings = table.settings;
+        this.cursor = cursor;
+        this.doc = doc.getDocument();
+    }
+    return HookData;
+}());
+var CellHookData = /** @class */ (function (_super) {
+    __extends(CellHookData, _super);
+    function CellHookData(doc, table, cell, row, column, cursor) {
+        var _this = _super.call(this, doc, table, cursor) || this;
+        _this.cell = cell;
+        _this.row = row;
+        _this.column = column;
+        _this.section = row.section;
+        return _this;
+    }
+    return CellHookData;
+}(HookData));
+
+var Table = /** @class */ (function () {
+    function Table(input, content) {
+        this.pageNumber = 1;
+        this.id = input.id;
+        this.settings = input.settings;
+        this.styles = input.styles;
+        this.hooks = input.hooks;
+        this.columns = content.columns;
+        this.head = content.head;
+        this.body = content.body;
+        this.foot = content.foot;
+    }
+    Table.prototype.getHeadHeight = function (columns) {
+        return this.head.reduce(function (acc, row) { return acc + row.getMaxCellHeight(columns); }, 0);
+    };
+    Table.prototype.getFootHeight = function (columns) {
+        return this.foot.reduce(function (acc, row) { return acc + row.getMaxCellHeight(columns); }, 0);
+    };
+    Table.prototype.allRows = function () {
+        return this.head.concat(this.body).concat(this.foot);
+    };
+    Table.prototype.callCellHooks = function (doc, handlers, cell, row, column, cursor) {
+        for (var _i = 0, handlers_1 = handlers; _i < handlers_1.length; _i++) {
+            var handler = handlers_1[_i];
+            var data = new CellHookData(doc, this, cell, row, column, cursor);
+            var result = handler(data) === false;
+            // Make sure text is always string[] since user can assign string
+            cell.text = Array.isArray(cell.text) ? cell.text : [cell.text];
+            if (result) {
+                return false;
+            }
+        }
+        return true;
+    };
+    Table.prototype.callEndPageHooks = function (doc, cursor) {
+        doc.applyStyles(doc.userStyles);
+        for (var _i = 0, _a = this.hooks.didDrawPage; _i < _a.length; _i++) {
+            var handler = _a[_i];
+            handler(new HookData(doc, this, cursor));
+        }
+    };
+    Table.prototype.callWillDrawPageHooks = function (doc, cursor) {
+        for (var _i = 0, _a = this.hooks.willDrawPage; _i < _a.length; _i++) {
+            var handler = _a[_i];
+            handler(new HookData(doc, this, cursor));
+        }
+    };
+    Table.prototype.getWidth = function (pageWidth) {
+        if (typeof this.settings.tableWidth === 'number') {
+            return this.settings.tableWidth;
+        }
+        else if (this.settings.tableWidth === 'wrap') {
+            var wrappedWidth = this.columns.reduce(function (total, col) { return total + col.wrappedWidth; }, 0);
+            return wrappedWidth;
+        }
+        else {
+            var margin = this.settings.margin;
+            return pageWidth - margin.left - margin.right;
+        }
+    };
+    return Table;
+}());
+var Row = /** @class */ (function () {
+    function Row(raw, index, section, cells, spansMultiplePages) {
+        if (spansMultiplePages === void 0) { spansMultiplePages = false; }
+        this.height = 0;
+        this.raw = raw;
+        if (raw instanceof HtmlRowInput) {
+            this.raw = raw._element;
+            this.element = raw._element;
+        }
+        this.index = index;
+        this.section = section;
+        this.cells = cells;
+        this.spansMultiplePages = spansMultiplePages;
+    }
+    Row.prototype.getMaxCellHeight = function (columns) {
+        var _this = this;
+        return columns.reduce(function (acc, column) { var _a; return Math.max(acc, ((_a = _this.cells[column.index]) === null || _a === void 0 ? void 0 : _a.height) || 0); }, 0);
+    };
+    Row.prototype.hasRowSpan = function (columns) {
+        var _this = this;
+        return (columns.filter(function (column) {
+            var cell = _this.cells[column.index];
+            if (!cell)
+                return false;
+            return cell.rowSpan > 1;
+        }).length > 0);
+    };
+    Row.prototype.canEntireRowFit = function (height, columns) {
+        return this.getMaxCellHeight(columns) <= height;
+    };
+    Row.prototype.getMinimumRowHeight = function (columns, doc) {
+        var _this = this;
+        return columns.reduce(function (acc, column) {
+            var cell = _this.cells[column.index];
+            if (!cell)
+                return 0;
+            var lineHeight = doc.getLineHeight(cell.styles.fontSize);
+            var vPadding = cell.padding('vertical');
+            var oneRowHeight = vPadding + lineHeight;
+            return oneRowHeight > acc ? oneRowHeight : acc;
+        }, 0);
+    };
+    return Row;
+}());
+var Cell = /** @class */ (function () {
+    function Cell(raw, styles, section) {
+        var _a;
+        this.contentHeight = 0;
+        this.contentWidth = 0;
+        this.wrappedWidth = 0;
+        this.minReadableWidth = 0;
+        this.minWidth = 0;
+        this.width = 0;
+        this.height = 0;
+        this.x = 0;
+        this.y = 0;
+        this.styles = styles;
+        this.section = section;
+        this.raw = raw;
+        var content = raw;
+        if (raw != null && typeof raw === 'object' && !Array.isArray(raw)) {
+            this.rowSpan = raw.rowSpan || 1;
+            this.colSpan = raw.colSpan || 1;
+            content = (_a = raw.content) !== null && _a !== void 0 ? _a : raw;
+            if (raw._element) {
+                this.raw = raw._element;
+            }
+        }
+        else {
+            this.rowSpan = 1;
+            this.colSpan = 1;
+        }
+        // Stringify 0 and false, but not undefined or null
+        var text = content != null ? '' + content : '';
+        var splitRegex = /\r\n|\r|\n/g;
+        this.text = text.split(splitRegex);
+    }
+    Cell.prototype.getTextPos = function () {
+        var y;
+        if (this.styles.valign === 'top') {
+            y = this.y + this.padding('top');
+        }
+        else if (this.styles.valign === 'bottom') {
+            y = this.y + this.height - this.padding('bottom');
+        }
+        else {
+            var netHeight = this.height - this.padding('vertical');
+            y = this.y + netHeight / 2 + this.padding('top');
+        }
+        var x;
+        if (this.styles.halign === 'right') {
+            x = this.x + this.width - this.padding('right');
+        }
+        else if (this.styles.halign === 'center') {
+            var netWidth = this.width - this.padding('horizontal');
+            x = this.x + netWidth / 2 + this.padding('left');
+        }
+        else {
+            x = this.x + this.padding('left');
+        }
+        return { x: x, y: y };
+    };
+    // TODO (v4): replace parameters with only (lineHeight)
+    Cell.prototype.getContentHeight = function (scaleFactor, lineHeightFactor) {
+        if (lineHeightFactor === void 0) { lineHeightFactor = 1.15; }
+        var lineCount = Array.isArray(this.text) ? this.text.length : 1;
+        var lineHeight = (this.styles.fontSize / scaleFactor) * lineHeightFactor;
+        var height = lineCount * lineHeight + this.padding('vertical');
+        return Math.max(height, this.styles.minCellHeight);
+    };
+    Cell.prototype.padding = function (name) {
+        var padding = parseSpacing(this.styles.cellPadding, 0);
+        if (name === 'vertical') {
+            return padding.top + padding.bottom;
+        }
+        else if (name === 'horizontal') {
+            return padding.left + padding.right;
+        }
+        else {
+            return padding[name];
+        }
+    };
+    return Cell;
+}());
+var Column = /** @class */ (function () {
+    function Column(dataKey, raw, index) {
+        this.wrappedWidth = 0;
+        this.minReadableWidth = 0;
+        this.minWidth = 0;
+        this.width = 0;
+        this.dataKey = dataKey;
+        this.raw = raw;
+        this.index = index;
+    }
+    Column.prototype.getMaxCustomCellWidth = function (table) {
+        var max = 0;
+        for (var _i = 0, _a = table.allRows(); _i < _a.length; _i++) {
+            var row = _a[_i];
+            var cell = row.cells[this.index];
+            if (cell && typeof cell.styles.cellWidth === 'number') {
+                max = Math.max(max, cell.styles.cellWidth);
+            }
+        }
+        return max;
+    };
+    return Column;
+}());
+
+/**
+ * Calculate the column widths
+ */
+function calculateWidths(doc, table) {
+    calculate(doc, table);
+    var resizableColumns = [];
+    var initialTableWidth = 0;
+    table.columns.forEach(function (column) {
+        var customWidth = column.getMaxCustomCellWidth(table);
+        if (customWidth) {
+            // final column width
+            column.width = customWidth;
+        }
+        else {
+            // initial column width (will be resized)
+            column.width = column.wrappedWidth;
+            resizableColumns.push(column);
+        }
+        initialTableWidth += column.width;
+    });
+    // width difference that needs to be distributed
+    var resizeWidth = table.getWidth(doc.pageSize().width) - initialTableWidth;
+    // first resize attempt: with respect to minReadableWidth and minWidth
+    if (resizeWidth) {
+        resizeWidth = resizeColumns(resizableColumns, resizeWidth, function (column) {
+            return Math.max(column.minReadableWidth, column.minWidth);
+        });
+    }
+    // second resize attempt: ignore minReadableWidth but respect minWidth
+    if (resizeWidth) {
+        resizeWidth = resizeColumns(resizableColumns, resizeWidth, function (column) { return column.minWidth; });
+    }
+    resizeWidth = Math.abs(resizeWidth);
+    if (!table.settings.horizontalPageBreak &&
+        resizeWidth > 0.1 / doc.scaleFactor()) {
+        // Table can't get smaller due to custom-width or minWidth restrictions
+        // We can't really do much here. Up to user to for example
+        // reduce font size, increase page size or remove custom cell widths
+        // to allow more columns to be reduced in size
+        resizeWidth = resizeWidth < 1 ? resizeWidth : Math.round(resizeWidth);
+        console.log("Of the table content, ".concat(resizeWidth, " units width could not fit page"));
+    }
+    applyColSpans(table);
+    fitContent(table, doc);
+    applyRowSpans(table);
+}
+function calculate(doc, table) {
+    var sf = doc.scaleFactor();
+    var horizontalPageBreak = table.settings.horizontalPageBreak;
+    var availablePageWidth = getPageAvailableWidth(doc, table);
+    table.allRows().forEach(function (row) {
+        for (var _i = 0, _a = table.columns; _i < _a.length; _i++) {
+            var column = _a[_i];
+            var cell = row.cells[column.index];
+            if (!cell)
+                continue;
+            var hooks = table.hooks.didParseCell;
+            table.callCellHooks(doc, hooks, cell, row, column, null);
+            var padding = cell.padding('horizontal');
+            cell.contentWidth = getStringWidth(cell.text, cell.styles, doc) + padding;
+            // Using [^\S\u00A0] instead of \s ensures that we split the text on all
+            // whitespace except non-breaking spaces (\u00A0). We need to preserve
+            // them in the split process to ensure correct word separation and width
+            // calculation.
+            var longestWordWidth = getStringWidth(cell.text.join(' ').split(/[^\S\u00A0]+/), cell.styles, doc);
+            cell.minReadableWidth = longestWordWidth + cell.padding('horizontal');
+            if (typeof cell.styles.cellWidth === 'number') {
+                cell.minWidth = cell.styles.cellWidth;
+                cell.wrappedWidth = cell.styles.cellWidth;
+            }
+            else if (cell.styles.cellWidth === 'wrap' ||
+                horizontalPageBreak === true) {
+                // cell width should not be more than available page width
+                if (cell.contentWidth > availablePageWidth) {
+                    cell.minWidth = availablePageWidth;
+                    cell.wrappedWidth = availablePageWidth;
+                }
+                else {
+                    cell.minWidth = cell.contentWidth;
+                    cell.wrappedWidth = cell.contentWidth;
+                }
+            }
+            else {
+                // auto
+                var defaultMinWidth = 10 / sf;
+                cell.minWidth = cell.styles.minCellWidth || defaultMinWidth;
+                cell.wrappedWidth = cell.contentWidth;
+                if (cell.minWidth > cell.wrappedWidth) {
+                    cell.wrappedWidth = cell.minWidth;
+                }
+            }
+        }
+    });
+    table.allRows().forEach(function (row) {
+        for (var _i = 0, _a = table.columns; _i < _a.length; _i++) {
+            var column = _a[_i];
+            var cell = row.cells[column.index];
+            // For now we ignore the minWidth and wrappedWidth of colspan cells when calculating colspan widths.
+            // Could probably be improved upon however.
+            if (cell && cell.colSpan === 1) {
+                column.wrappedWidth = Math.max(column.wrappedWidth, cell.wrappedWidth);
+                column.minWidth = Math.max(column.minWidth, cell.minWidth);
+                column.minReadableWidth = Math.max(column.minReadableWidth, cell.minReadableWidth);
+            }
+            else {
+                // Respect cellWidth set in columnStyles even if there is no cells for this column
+                // or if the column only have colspan cells. Since the width of colspan cells
+                // does not affect the width of columns, setting columnStyles cellWidth enables the
+                // user to at least do it manually.
+                // Note that this is not perfect for now since for example row and table styles are
+                // not accounted for
+                var columnStyles = table.styles.columnStyles[column.dataKey] ||
+                    table.styles.columnStyles[column.index] ||
+                    {};
+                var cellWidth = columnStyles.cellWidth || columnStyles.minCellWidth;
+                if (cellWidth && typeof cellWidth === 'number') {
+                    column.minWidth = cellWidth;
+                    column.wrappedWidth = cellWidth;
+                }
+            }
+            if (cell) {
+                // Make sure all columns get at least min width even though width calculations are not based on them
+                if (cell.colSpan > 1 && !column.minWidth) {
+                    column.minWidth = cell.minWidth;
+                }
+                if (cell.colSpan > 1 && !column.wrappedWidth) {
+                    column.wrappedWidth = cell.minWidth;
+                }
+            }
+        }
+    });
+}
+/**
+ * Distribute resizeWidth on passed resizable columns
+ */
+function resizeColumns(columns, resizeWidth, getMinWidth) {
+    var initialResizeWidth = resizeWidth;
+    var sumWrappedWidth = columns.reduce(function (acc, column) { return acc + column.wrappedWidth; }, 0);
+    for (var i = 0; i < columns.length; i++) {
+        var column = columns[i];
+        var ratio = column.wrappedWidth / sumWrappedWidth;
+        var suggestedChange = initialResizeWidth * ratio;
+        var suggestedWidth = column.width + suggestedChange;
+        var minWidth = getMinWidth(column);
+        var newWidth = suggestedWidth < minWidth ? minWidth : suggestedWidth;
+        resizeWidth -= newWidth - column.width;
+        column.width = newWidth;
+    }
+    resizeWidth = Math.round(resizeWidth * 1e10) / 1e10;
+    // Run the resizer again if there's remaining width needs
+    // to be distributed and there're columns that can be resized
+    if (resizeWidth) {
+        var resizableColumns = columns.filter(function (column) {
+            return resizeWidth < 0
+                ? column.width > getMinWidth(column) // check if column can shrink
+                : true; // check if column can grow
+        });
+        if (resizableColumns.length) {
+            resizeWidth = resizeColumns(resizableColumns, resizeWidth, getMinWidth);
+        }
+    }
+    return resizeWidth;
+}
+function applyRowSpans(table) {
+    var rowSpanCells = {};
+    var colRowSpansLeft = 1;
+    var all = table.allRows();
+    for (var rowIndex = 0; rowIndex < all.length; rowIndex++) {
+        var row = all[rowIndex];
+        for (var _i = 0, _a = table.columns; _i < _a.length; _i++) {
+            var column = _a[_i];
+            var data = rowSpanCells[column.index];
+            if (colRowSpansLeft > 1) {
+                colRowSpansLeft--;
+                delete row.cells[column.index];
+            }
+            else if (data) {
+                data.cell.height += row.height;
+                colRowSpansLeft = data.cell.colSpan;
+                delete row.cells[column.index];
+                data.left--;
+                if (data.left <= 1) {
+                    delete rowSpanCells[column.index];
+                }
+            }
+            else {
+                var cell = row.cells[column.index];
+                if (!cell) {
+                    continue;
+                }
+                cell.height = row.height;
+                if (cell.rowSpan > 1) {
+                    var remaining = all.length - rowIndex;
+                    var left = cell.rowSpan > remaining ? remaining : cell.rowSpan;
+                    rowSpanCells[column.index] = { cell: cell, left: left, row: row };
+                }
+            }
+        }
+    }
+}
+function applyColSpans(table) {
+    var all = table.allRows();
+    for (var rowIndex = 0; rowIndex < all.length; rowIndex++) {
+        var row = all[rowIndex];
+        var colSpanCell = null;
+        var combinedColSpanWidth = 0;
+        var colSpansLeft = 0;
+        for (var columnIndex = 0; columnIndex < table.columns.length; columnIndex++) {
+            var column = table.columns[columnIndex];
+            // Width and colspan
+            colSpansLeft -= 1;
+            if (colSpansLeft > 1 && table.columns[columnIndex + 1]) {
+                combinedColSpanWidth += column.width;
+                delete row.cells[column.index];
+            }
+            else if (colSpanCell) {
+                var cell = colSpanCell;
+                delete row.cells[column.index];
+                colSpanCell = null;
+                cell.width = column.width + combinedColSpanWidth;
+            }
+            else {
+                var cell = row.cells[column.index];
+                if (!cell)
+                    continue;
+                colSpansLeft = cell.colSpan;
+                combinedColSpanWidth = 0;
+                if (cell.colSpan > 1) {
+                    colSpanCell = cell;
+                    combinedColSpanWidth += column.width;
+                    continue;
+                }
+                cell.width = column.width + combinedColSpanWidth;
+            }
+        }
+    }
+}
+function fitContent(table, doc) {
+    var rowSpanHeight = { count: 0, height: 0 };
+    for (var _i = 0, _a = table.allRows(); _i < _a.length; _i++) {
+        var row = _a[_i];
+        for (var _b = 0, _c = table.columns; _b < _c.length; _b++) {
+            var column = _c[_b];
+            var cell = row.cells[column.index];
+            if (!cell)
+                continue;
+            doc.applyStyles(cell.styles, true);
+            var textSpace = cell.width - cell.padding('horizontal');
+            if (cell.styles.overflow === 'linebreak') {
+                // Add one pt to textSpace to fix rounding error
+                cell.text = doc.splitTextToSize(cell.text, textSpace + 1 / doc.scaleFactor(), { fontSize: cell.styles.fontSize });
+            }
+            else if (cell.styles.overflow === 'ellipsize') {
+                cell.text = ellipsize(cell.text, textSpace, cell.styles, doc, '...');
+            }
+            else if (cell.styles.overflow === 'hidden') {
+                cell.text = ellipsize(cell.text, textSpace, cell.styles, doc, '');
+            }
+            else if (typeof cell.styles.overflow === 'function') {
+                var result = cell.styles.overflow(cell.text, textSpace);
+                if (typeof result === 'string') {
+                    cell.text = [result];
+                }
+                else {
+                    cell.text = result;
+                }
+            }
+            cell.contentHeight = cell.getContentHeight(doc.scaleFactor(), doc.getLineHeightFactor());
+            var realContentHeight = cell.contentHeight / cell.rowSpan;
+            if (cell.rowSpan > 1 &&
+                rowSpanHeight.count * rowSpanHeight.height <
+                    realContentHeight * cell.rowSpan) {
+                rowSpanHeight = { height: realContentHeight, count: cell.rowSpan };
+            }
+            else if (rowSpanHeight && rowSpanHeight.count > 0) {
+                if (rowSpanHeight.height > realContentHeight) {
+                    realContentHeight = rowSpanHeight.height;
+                }
+            }
+            if (realContentHeight > row.height) {
+                row.height = realContentHeight;
+            }
+        }
+        rowSpanHeight.count--;
+    }
+}
+function ellipsize(text, width, styles, doc, overflow) {
+    return text.map(function (str) { return ellipsizeStr(str, width, styles, doc, overflow); });
+}
+function ellipsizeStr(text, width, styles, doc, overflow) {
+    var precision = 10000 * doc.scaleFactor();
+    width = Math.ceil(width * precision) / precision;
+    if (width >= getStringWidth(text, styles, doc)) {
+        return text;
+    }
+    while (width < getStringWidth(text + overflow, styles, doc)) {
+        if (text.length <= 1) {
+            break;
+        }
+        text = text.substring(0, text.length - 1);
+    }
+    return text.trim() + overflow;
+}
+
+function createTable(jsPDFDoc, input) {
+    var doc = new DocHandler(jsPDFDoc);
+    var content = parseContent(input, doc.scaleFactor());
+    var table = new Table(input, content);
+    calculateWidths(doc, table);
+    doc.applyStyles(doc.userStyles);
+    return table;
+}
+function parseContent(input, sf) {
+    var content = input.content;
+    var columns = createColumns(content.columns);
+    // If no head or foot is set, try generating it with content from columns
+    if (content.head.length === 0) {
+        var sectionRow = generateSectionRow(columns, 'head');
+        if (sectionRow)
+            content.head.push(sectionRow);
+    }
+    if (content.foot.length === 0) {
+        var sectionRow = generateSectionRow(columns, 'foot');
+        if (sectionRow)
+            content.foot.push(sectionRow);
+    }
+    var theme = input.settings.theme;
+    var styles = input.styles;
+    return {
+        columns: columns,
+        head: parseSection('head', content.head, columns, styles, theme, sf),
+        body: parseSection('body', content.body, columns, styles, theme, sf),
+        foot: parseSection('foot', content.foot, columns, styles, theme, sf),
+    };
+}
+function parseSection(sectionName, sectionRows, columns, styleProps, theme, scaleFactor) {
+    var rowSpansLeftForColumn = {};
+    var result = sectionRows.map(function (rawRow, rowIndex) {
+        var skippedRowForRowSpans = 0;
+        var cells = {};
+        var colSpansAdded = 0;
+        var columnSpansLeft = 0;
+        for (var _i = 0, columns_1 = columns; _i < columns_1.length; _i++) {
+            var column = columns_1[_i];
+            if (rowSpansLeftForColumn[column.index] == null ||
+                rowSpansLeftForColumn[column.index].left === 0) {
+                if (columnSpansLeft === 0) {
+                    var rawCell = void 0;
+                    if (Array.isArray(rawRow)) {
+                        rawCell =
+                            rawRow[column.index - colSpansAdded - skippedRowForRowSpans];
+                    }
+                    else {
+                        rawCell = rawRow[column.dataKey];
+                    }
+                    var cellInputStyles = {};
+                    if (typeof rawCell === 'object' && !Array.isArray(rawCell)) {
+                        cellInputStyles = (rawCell === null || rawCell === void 0 ? void 0 : rawCell.styles) || {};
+                    }
+                    var styles = cellStyles(sectionName, column, rowIndex, theme, styleProps, scaleFactor, cellInputStyles);
+                    var cell = new Cell(rawCell, styles, sectionName);
+                    // dataKey is not used internally no more but keep for
+                    // backwards compat in hooks
+                    cells[column.dataKey] = cell;
+                    cells[column.index] = cell;
+                    columnSpansLeft = cell.colSpan - 1;
+                    rowSpansLeftForColumn[column.index] = {
+                        left: cell.rowSpan - 1,
+                        times: columnSpansLeft,
+                    };
+                }
+                else {
+                    columnSpansLeft--;
+                    colSpansAdded++;
+                }
+            }
+            else {
+                rowSpansLeftForColumn[column.index].left--;
+                columnSpansLeft = rowSpansLeftForColumn[column.index].times;
+                skippedRowForRowSpans++;
+            }
+        }
+        return new Row(rawRow, rowIndex, sectionName, cells);
+    });
+    return result;
+}
+function generateSectionRow(columns, section) {
+    var sectionRow = {};
+    columns.forEach(function (col) {
+        if (col.raw != null) {
+            var title = getSectionTitle(section, col.raw);
+            if (title != null)
+                sectionRow[col.dataKey] = title;
+        }
+    });
+    return Object.keys(sectionRow).length > 0 ? sectionRow : null;
+}
+function getSectionTitle(section, column) {
+    if (section === 'head') {
+        if (typeof column === 'object') {
+            return column.header || null;
+        }
+        else if (typeof column === 'string' || typeof column === 'number') {
+            return column;
+        }
+    }
+    else if (section === 'foot' && typeof column === 'object') {
+        return column.footer;
+    }
+    return null;
+}
+function createColumns(columns) {
+    return columns.map(function (input, index) {
+        var _a;
+        var key;
+        if (typeof input === 'object') {
+            key = (_a = input.dataKey) !== null && _a !== void 0 ? _a : index;
+        }
+        else {
+            key = index;
+        }
+        return new Column(key, input, index);
+    });
+}
+function cellStyles(sectionName, column, rowIndex, themeName, styles, scaleFactor, cellInputStyles) {
+    var theme = getTheme(themeName);
+    var sectionStyles;
+    if (sectionName === 'head') {
+        sectionStyles = styles.headStyles;
+    }
+    else if (sectionName === 'body') {
+        sectionStyles = styles.bodyStyles;
+    }
+    else if (sectionName === 'foot') {
+        sectionStyles = styles.footStyles;
+    }
+    var otherStyles = assign({}, theme.table, theme[sectionName], styles.styles, sectionStyles);
+    var columnStyles = styles.columnStyles[column.dataKey] ||
+        styles.columnStyles[column.index] ||
+        {};
+    var colStyles = sectionName === 'body' ? columnStyles : {};
+    var rowStyles = sectionName === 'body' && rowIndex % 2 === 0
+        ? assign({}, theme.alternateRow, styles.alternateRowStyles)
+        : {};
+    var defaultStyle = defaultStyles(scaleFactor);
+    var themeStyles = assign({}, defaultStyle, otherStyles, rowStyles, colStyles);
+    return assign(themeStyles, cellInputStyles);
+}
+
+// get columns can be fit into page
+function getColumnsCanFitInPage(doc, table, config) {
+    var _a;
+    if (config === void 0) { config = {}; }
+    // Get page width
+    var remainingWidth = getPageAvailableWidth(doc, table);
+    // Get column data key to repeat
+    var repeatColumnsMap = new Map();
+    var colIndexes = [];
+    var columns = [];
+    var horizontalPageBreakRepeat = [];
+    if (Array.isArray(table.settings.horizontalPageBreakRepeat)) {
+        horizontalPageBreakRepeat = table.settings.horizontalPageBreakRepeat;
+        // It can be a single value of type string or number (even number: 0)
+    }
+    else if (typeof table.settings.horizontalPageBreakRepeat === 'string' ||
+        typeof table.settings.horizontalPageBreakRepeat === 'number') {
+        horizontalPageBreakRepeat = [table.settings.horizontalPageBreakRepeat];
+    }
+    // Code to repeat the given column in split pages
+    horizontalPageBreakRepeat.forEach(function (field) {
+        var col = table.columns.find(function (item) { return item.dataKey === field || item.index === field; });
+        if (col && !repeatColumnsMap.has(col.index)) {
+            repeatColumnsMap.set(col.index, true);
+            colIndexes.push(col.index);
+            columns.push(table.columns[col.index]);
+            remainingWidth -= col.wrappedWidth;
+        }
+    });
+    var first = true;
+    var i = (_a = config === null || config === void 0 ? void 0 : config.start) !== null && _a !== void 0 ? _a : 0; // make sure couter is initiated outside the loop
+    while (i < table.columns.length) {
+        // Prevent duplicates
+        if (repeatColumnsMap.has(i)) {
+            i++;
+            continue;
+        }
+        var colWidth = table.columns[i].wrappedWidth;
+        // Take at least one column even if it doesn't fit
+        if (first || remainingWidth >= colWidth) {
+            first = false;
+            colIndexes.push(i);
+            columns.push(table.columns[i]);
+            remainingWidth -= colWidth;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    return { colIndexes: colIndexes, columns: columns, lastIndex: i - 1 };
+}
+function calculateAllColumnsCanFitInPage(doc, table) {
+    var allResults = [];
+    for (var i = 0; i < table.columns.length; i++) {
+        var result = getColumnsCanFitInPage(doc, table, { start: i });
+        if (result.columns.length) {
+            allResults.push(result);
+            i = result.lastIndex;
+        }
+    }
+    return allResults;
+}
+
+function drawTable(jsPDFDoc, table) {
+    var settings = table.settings;
+    var startY = settings.startY;
+    var margin = settings.margin;
+    var cursor = { x: margin.left, y: startY };
+    var sectionsHeight = table.getHeadHeight(table.columns) + table.getFootHeight(table.columns);
+    var minTableBottomPos = startY + margin.bottom + sectionsHeight;
+    if (settings.pageBreak === 'avoid') {
+        var rows = table.body;
+        var tableHeight = rows.reduce(function (acc, row) { return acc + row.height; }, 0);
+        minTableBottomPos += tableHeight;
+    }
+    var doc = new DocHandler(jsPDFDoc);
+    if (settings.pageBreak === 'always' ||
+        (settings.startY != null && minTableBottomPos > doc.pageSize().height)) {
+        nextPage(doc);
+        cursor.y = margin.top;
+    }
+    table.callWillDrawPageHooks(doc, cursor);
+    var startPos = assign({}, cursor);
+    table.startPageNumber = doc.pageNumber();
+    if (settings.horizontalPageBreak) {
+        // managed flow for split columns
+        printTableWithHorizontalPageBreak(doc, table, startPos, cursor);
+    }
+    else {
+        // normal flow
+        doc.applyStyles(doc.userStyles);
+        if (settings.showHead === 'firstPage' ||
+            settings.showHead === 'everyPage') {
+            table.head.forEach(function (row) {
+                return printRow(doc, table, row, cursor, table.columns);
+            });
+        }
+        doc.applyStyles(doc.userStyles);
+        table.body.forEach(function (row, index) {
+            var isLastRow = index === table.body.length - 1;
+            printFullRow(doc, table, row, isLastRow, startPos, cursor, table.columns);
+        });
+        doc.applyStyles(doc.userStyles);
+        if (settings.showFoot === 'lastPage' || settings.showFoot === 'everyPage') {
+            table.foot.forEach(function (row) {
+                return printRow(doc, table, row, cursor, table.columns);
+            });
+        }
+    }
+    addTableBorder(doc, table, startPos, cursor);
+    table.callEndPageHooks(doc, cursor);
+    table.finalY = cursor.y;
+    jsPDFDoc.lastAutoTable = table;
+    doc.applyStyles(doc.userStyles);
+}
+function printTableWithHorizontalPageBreak(doc, table, startPos, cursor) {
+    // calculate width of columns and render only those which can fit into page
+    var allColumnsCanFitResult = calculateAllColumnsCanFitInPage(doc, table);
+    var settings = table.settings;
+    if (settings.horizontalPageBreakBehaviour === 'afterAllRows') {
+        allColumnsCanFitResult.forEach(function (colsAndIndexes, index) {
+            doc.applyStyles(doc.userStyles);
+            // add page to print next columns in new page
+            if (index > 0) {
+                // When adding a page here, make sure not to print the footers
+                // because they were already printed before on this same loop
+                addPage(doc, table, startPos, cursor, colsAndIndexes.columns, true);
+            }
+            else {
+                // print head for selected columns
+                printHead(doc, table, cursor, colsAndIndexes.columns);
+            }
+            // print body & footer for selected columns
+            printBody(doc, table, startPos, cursor, colsAndIndexes.columns);
+            printFoot(doc, table, cursor, colsAndIndexes.columns);
+        });
+    }
+    else {
+        var lastRowIndexOfLastPage_1 = -1;
+        var firstColumnsToFitResult = allColumnsCanFitResult[0];
+        var _loop_1 = function () {
+            // Print the first columns, taking note of the last row printed
+            var lastPrintedRowIndex = lastRowIndexOfLastPage_1;
+            if (firstColumnsToFitResult) {
+                doc.applyStyles(doc.userStyles);
+                var firstColumnsToFit = firstColumnsToFitResult.columns;
+                if (lastRowIndexOfLastPage_1 >= 0) {
+                    // When adding a page here, make sure not to print the footers
+                    // because they were already printed before on this same loop
+                    addPage(doc, table, startPos, cursor, firstColumnsToFit, true);
+                }
+                else {
+                    printHead(doc, table, cursor, firstColumnsToFit);
+                }
+                lastPrintedRowIndex = printBodyWithoutPageBreaks(doc, table, lastRowIndexOfLastPage_1 + 1, cursor, firstColumnsToFit);
+                printFoot(doc, table, cursor, firstColumnsToFit);
+            }
+            // Check how many rows were printed, so that the next columns would not print more rows than that
+            var maxNumberOfRows = lastPrintedRowIndex - lastRowIndexOfLastPage_1;
+            // Print the next columns, never exceding maxNumberOfRows
+            allColumnsCanFitResult.slice(1).forEach(function (colsAndIndexes) {
+                doc.applyStyles(doc.userStyles);
+                // When adding a page here, make sure not to print the footers
+                // because they were already printed before on this same loop
+                addPage(doc, table, startPos, cursor, colsAndIndexes.columns, true);
+                printBodyWithoutPageBreaks(doc, table, lastRowIndexOfLastPage_1 + 1, cursor, colsAndIndexes.columns, maxNumberOfRows);
+                printFoot(doc, table, cursor, colsAndIndexes.columns);
+            });
+            lastRowIndexOfLastPage_1 = lastPrintedRowIndex;
+        };
+        while (lastRowIndexOfLastPage_1 < table.body.length - 1) {
+            _loop_1();
+        }
+    }
+}
+function printHead(doc, table, cursor, columns) {
+    var settings = table.settings;
+    doc.applyStyles(doc.userStyles);
+    if (settings.showHead === 'firstPage' || settings.showHead === 'everyPage') {
+        table.head.forEach(function (row) { return printRow(doc, table, row, cursor, columns); });
+    }
+}
+function printBody(doc, table, startPos, cursor, columns) {
+    doc.applyStyles(doc.userStyles);
+    table.body.forEach(function (row, index) {
+        var isLastRow = index === table.body.length - 1;
+        printFullRow(doc, table, row, isLastRow, startPos, cursor, columns);
+    });
+}
+function printBodyWithoutPageBreaks(doc, table, startRowIndex, cursor, columns, maxNumberOfRows) {
+    doc.applyStyles(doc.userStyles);
+    maxNumberOfRows = maxNumberOfRows !== null && maxNumberOfRows !== void 0 ? maxNumberOfRows : table.body.length;
+    var endRowIndex = Math.min(startRowIndex + maxNumberOfRows, table.body.length);
+    var lastPrintedRowIndex = -1;
+    var rows = table.body.slice(startRowIndex, endRowIndex);
+    for (var index = 0; index < rows.length; index++) {
+        var row = rows[index];
+        var isLastRow = startRowIndex + index === table.body.length - 1;
+        var remainingSpace = getRemainingPageSpace(doc, table, isLastRow, cursor);
+        if (row.canEntireRowFit(remainingSpace, columns)) {
+            printRow(doc, table, row, cursor, columns);
+            lastPrintedRowIndex = startRowIndex + index;
+        }
+        else {
+            break;
+        }
+    }
+    return lastPrintedRowIndex;
+}
+function printFoot(doc, table, cursor, columns) {
+    var settings = table.settings;
+    doc.applyStyles(doc.userStyles);
+    if (settings.showFoot === 'lastPage' || settings.showFoot === 'everyPage') {
+        table.foot.forEach(function (row) { return printRow(doc, table, row, cursor, columns); });
+    }
+}
+function getRemainingLineCount(cell, remainingPageSpace, doc) {
+    var lineHeight = doc.getLineHeight(cell.styles.fontSize);
+    var vPadding = cell.padding('vertical');
+    var remainingLines = Math.floor((remainingPageSpace - vPadding) / lineHeight);
+    return Math.max(0, remainingLines);
+}
+function modifyRowToFit(row, remainingPageSpace, table, doc) {
+    var cells = {};
+    row.spansMultiplePages = true;
+    row.height = 0;
+    var rowHeight = 0;
+    for (var _i = 0, _a = table.columns; _i < _a.length; _i++) {
+        var column = _a[_i];
+        var cell = row.cells[column.index];
+        if (!cell)
+            continue;
+        if (!Array.isArray(cell.text)) {
+            cell.text = [cell.text];
+        }
+        var remainderCell = new Cell(cell.raw, cell.styles, cell.section);
+        remainderCell = assign(remainderCell, cell);
+        remainderCell.text = [];
+        var remainingLineCount = getRemainingLineCount(cell, remainingPageSpace, doc);
+        if (cell.text.length > remainingLineCount) {
+            remainderCell.text = cell.text.splice(remainingLineCount, cell.text.length);
+        }
+        var scaleFactor = doc.scaleFactor();
+        var lineHeightFactor = doc.getLineHeightFactor();
+        cell.contentHeight = cell.getContentHeight(scaleFactor, lineHeightFactor);
+        if (cell.contentHeight >= remainingPageSpace) {
+            cell.contentHeight = remainingPageSpace;
+            remainderCell.styles.minCellHeight -= remainingPageSpace;
+        }
+        if (cell.contentHeight > row.height) {
+            row.height = cell.contentHeight;
+        }
+        remainderCell.contentHeight = remainderCell.getContentHeight(scaleFactor, lineHeightFactor);
+        if (remainderCell.contentHeight > rowHeight) {
+            rowHeight = remainderCell.contentHeight;
+        }
+        cells[column.index] = remainderCell;
+    }
+    var remainderRow = new Row(row.raw, -1, row.section, cells, true);
+    remainderRow.height = rowHeight;
+    for (var _b = 0, _c = table.columns; _b < _c.length; _b++) {
+        var column = _c[_b];
+        var remainderCell = remainderRow.cells[column.index];
+        if (remainderCell) {
+            remainderCell.height = remainderRow.height;
+        }
+        var cell = row.cells[column.index];
+        if (cell) {
+            cell.height = row.height;
+        }
+    }
+    return remainderRow;
+}
+function shouldPrintOnCurrentPage(doc, row, remainingPageSpace, table) {
+    var pageHeight = doc.pageSize().height;
+    var margin = table.settings.margin;
+    var marginHeight = margin.top + margin.bottom;
+    var maxRowHeight = pageHeight - marginHeight;
+    if (row.section === 'body') {
+        // Should also take into account that head and foot is not
+        // on every page with some settings
+        maxRowHeight -=
+            table.getHeadHeight(table.columns) + table.getFootHeight(table.columns);
+    }
+    var minRowHeight = row.getMinimumRowHeight(table.columns, doc);
+    var minRowFits = minRowHeight < remainingPageSpace;
+    if (minRowHeight > maxRowHeight) {
+        console.log("Will not be able to print row ".concat(row.index, " correctly since it's minimum height is larger than page height"));
+        return true;
+    }
+    if (!minRowFits) {
+        return false;
+    }
+    var rowHasRowSpanCell = row.hasRowSpan(table.columns);
+    var rowHigherThanPage = row.getMaxCellHeight(table.columns) > maxRowHeight;
+    if (rowHigherThanPage) {
+        if (rowHasRowSpanCell) {
+            console.log("The content of row ".concat(row.index, " will not be drawn correctly since drawing rows with a height larger than the page height and has cells with rowspans is not supported."));
+        }
+        return true;
+    }
+    if (rowHasRowSpanCell) {
+        // Currently a new page is required whenever a rowspan row don't fit a page.
+        return false;
+    }
+    if (table.settings.rowPageBreak === 'avoid') {
+        return false;
+    }
+    // In all other cases print the row on current page
+    return true;
+}
+function printFullRow(doc, table, row, isLastRow, startPos, cursor, columns) {
+    var remainingSpace = getRemainingPageSpace(doc, table, isLastRow, cursor);
+    if (row.canEntireRowFit(remainingSpace, columns)) {
+        // The row fits in the current page
+        printRow(doc, table, row, cursor, columns);
+    }
+    else if (shouldPrintOnCurrentPage(doc, row, remainingSpace, table)) {
+        // The row gets split in two here, each piece in one page
+        var remainderRow = modifyRowToFit(row, remainingSpace, table, doc);
+        printRow(doc, table, row, cursor, columns);
+        addPage(doc, table, startPos, cursor, columns);
+        printFullRow(doc, table, remainderRow, isLastRow, startPos, cursor, columns);
+    }
+    else {
+        // The row get printed entirelly on the next page
+        addPage(doc, table, startPos, cursor, columns);
+        printFullRow(doc, table, row, isLastRow, startPos, cursor, columns);
+    }
+}
+function printRow(doc, table, row, cursor, columns) {
+    cursor.x = table.settings.margin.left;
+    for (var _i = 0, columns_1 = columns; _i < columns_1.length; _i++) {
+        var column = columns_1[_i];
+        var cell = row.cells[column.index];
+        if (!cell) {
+            cursor.x += column.width;
+            continue;
+        }
+        doc.applyStyles(cell.styles);
+        cell.x = cursor.x;
+        cell.y = cursor.y;
+        var result = table.callCellHooks(doc, table.hooks.willDrawCell, cell, row, column, cursor);
+        if (result === false) {
+            cursor.x += column.width;
+            continue;
+        }
+        drawCellRect(doc, cell, cursor);
+        var textPos = cell.getTextPos();
+        autoTableText(cell.text, textPos.x, textPos.y, {
+            halign: cell.styles.halign,
+            valign: cell.styles.valign,
+            maxWidth: Math.ceil(cell.width - cell.padding('left') - cell.padding('right')),
+        }, doc.getDocument());
+        table.callCellHooks(doc, table.hooks.didDrawCell, cell, row, column, cursor);
+        cursor.x += column.width;
+    }
+    cursor.y += row.height;
+}
+function drawCellRect(doc, cell, cursor) {
+    var cellStyles = cell.styles;
+    // https://github.com/simonbengtsson/jsPDF-AutoTable/issues/774
+    // TODO (v4): better solution?
+    doc.getDocument().setFillColor(doc.getDocument().getFillColor());
+    if (typeof cellStyles.lineWidth === 'number') {
+        // Draw cell background with normal borders
+        var fillStyle = getFillStyle(cellStyles.lineWidth, cellStyles.fillColor);
+        if (fillStyle) {
+            doc.rect(cell.x, cursor.y, cell.width, cell.height, fillStyle);
+        }
+    }
+    else if (typeof cellStyles.lineWidth === 'object') {
+        // Draw cell background
+        if (cellStyles.fillColor) {
+            doc.rect(cell.x, cursor.y, cell.width, cell.height, 'F');
+        }
+        // Draw cell individual borders
+        drawCellBorders(doc, cell, cursor, cellStyles.lineWidth);
+    }
+}
+/**
+ * Draw all specified borders. Borders are centered on cell's edge and lengthened
+ * to overlap with neighbours to create sharp corners.
+ * @param doc
+ * @param cell
+ * @param cursor
+ * @param fillColor
+ * @param lineWidth
+ */
+function drawCellBorders(doc, cell, cursor, lineWidth) {
+    var x1, y1, x2, y2;
+    if (lineWidth.top) {
+        x1 = cursor.x;
+        y1 = cursor.y;
+        x2 = cursor.x + cell.width;
+        y2 = cursor.y;
+        if (lineWidth.right) {
+            x2 += 0.5 * lineWidth.right;
+        }
+        if (lineWidth.left) {
+            x1 -= 0.5 * lineWidth.left;
+        }
+        drawLine(lineWidth.top, x1, y1, x2, y2);
+    }
+    if (lineWidth.bottom) {
+        x1 = cursor.x;
+        y1 = cursor.y + cell.height;
+        x2 = cursor.x + cell.width;
+        y2 = cursor.y + cell.height;
+        if (lineWidth.right) {
+            x2 += 0.5 * lineWidth.right;
+        }
+        if (lineWidth.left) {
+            x1 -= 0.5 * lineWidth.left;
+        }
+        drawLine(lineWidth.bottom, x1, y1, x2, y2);
+    }
+    if (lineWidth.left) {
+        x1 = cursor.x;
+        y1 = cursor.y;
+        x2 = cursor.x;
+        y2 = cursor.y + cell.height;
+        if (lineWidth.top) {
+            y1 -= 0.5 * lineWidth.top;
+        }
+        if (lineWidth.bottom) {
+            y2 += 0.5 * lineWidth.bottom;
+        }
+        drawLine(lineWidth.left, x1, y1, x2, y2);
+    }
+    if (lineWidth.right) {
+        x1 = cursor.x + cell.width;
+        y1 = cursor.y;
+        x2 = cursor.x + cell.width;
+        y2 = cursor.y + cell.height;
+        if (lineWidth.top) {
+            y1 -= 0.5 * lineWidth.top;
+        }
+        if (lineWidth.bottom) {
+            y2 += 0.5 * lineWidth.bottom;
+        }
+        drawLine(lineWidth.right, x1, y1, x2, y2);
+    }
+    function drawLine(width, x1, y1, x2, y2) {
+        doc.getDocument().setLineWidth(width);
+        doc.getDocument().line(x1, y1, x2, y2, 'S');
+    }
+}
+function getRemainingPageSpace(doc, table, isLastRow, cursor) {
+    var bottomContentHeight = table.settings.margin.bottom;
+    var showFoot = table.settings.showFoot;
+    if (showFoot === 'everyPage' || (showFoot === 'lastPage' && isLastRow)) {
+        bottomContentHeight += table.getFootHeight(table.columns);
+    }
+    return doc.pageSize().height - cursor.y - bottomContentHeight;
+}
+function addPage(doc, table, startPos, cursor, columns, suppressFooter) {
+    if (columns === void 0) { columns = []; }
+    if (suppressFooter === void 0) { suppressFooter = false; }
+    doc.applyStyles(doc.userStyles);
+    if (table.settings.showFoot === 'everyPage' && !suppressFooter) {
+        table.foot.forEach(function (row) { return printRow(doc, table, row, cursor, columns); });
+    }
+    // Add user content just before adding new page ensure it will
+    // be drawn above other things on the page
+    table.callEndPageHooks(doc, cursor);
+    var margin = table.settings.margin;
+    addTableBorder(doc, table, startPos, cursor);
+    nextPage(doc);
+    table.pageNumber++;
+    cursor.x = margin.left;
+    cursor.y = margin.top;
+    startPos.y = margin.top;
+    // call didAddPage hooks before any content is added to the page
+    table.callWillDrawPageHooks(doc, cursor);
+    if (table.settings.showHead === 'everyPage') {
+        table.head.forEach(function (row) { return printRow(doc, table, row, cursor, columns); });
+        doc.applyStyles(doc.userStyles);
+    }
+}
+function nextPage(doc) {
+    var current = doc.pageNumber();
+    doc.setPage(current + 1);
+    var newCurrent = doc.pageNumber();
+    if (newCurrent === current) {
+        doc.addPage();
+        return true;
+    }
+    return false;
+}
+
+function applyPlugin(jsPDF) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    jsPDF.API.autoTable = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var options = args[0];
+        var input = parseInput(this, options);
+        var table = createTable(this, input);
+        drawTable(this, table);
+        return this;
+    };
+    // Assign false to enable `doc.lastAutoTable.finalY || 40` sugar
+    jsPDF.API.lastAutoTable = false;
+    jsPDF.API.autoTableText = function (text, x, y, styles) {
+        autoTableText(text, x, y, styles, this);
+    };
+    jsPDF.API.autoTableSetDefaults = function (defaults) {
+        DocHandler.setDefaults(defaults, this);
+        return this;
+    };
+    jsPDF.autoTableSetDefaults = function (defaults, doc) {
+        DocHandler.setDefaults(defaults, doc);
+    };
+    jsPDF.API.autoTableHtmlToJson = function (tableElem, includeHiddenElements) {
+        var _a;
+        if (includeHiddenElements === void 0) { includeHiddenElements = false; }
+        if (typeof window === 'undefined') {
+            console.error('Cannot run autoTableHtmlToJson in non browser environment');
+            return null;
+        }
+        var doc = new DocHandler(this);
+        var _b = parseHtml(doc, tableElem, window, includeHiddenElements, false), head = _b.head, body = _b.body;
+        var columns = ((_a = head[0]) === null || _a === void 0 ? void 0 : _a.map(function (c) { return c.content; })) || [];
+        return { columns: columns, rows: body, data: body };
+    };
+}
+
+var _a;
+function autoTable(d, options) {
+    var input = parseInput(d, options);
+    var table = createTable(d, input);
+    drawTable(d, table);
+}
+// Experimental export
+function __createTable(d, options) {
+    var input = parseInput(d, options);
+    return createTable(d, input);
+}
+function __drawTable(d, table) {
+    drawTable(d, table);
+}
+try {
+    if (typeof window !== 'undefined' && window) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var anyWindow = window;
+        var jsPDF = anyWindow.jsPDF || ((_a = anyWindow.jspdf) === null || _a === void 0 ? void 0 : _a.jsPDF);
+        if (jsPDF) {
+            applyPlugin(jsPDF);
+        }
+    }
+}
+catch (error) {
+    console.error('Could not apply autoTable plugin', error);
+}
+
+var jspdf_plugin_autotable = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Cell: Cell,
+  CellHookData: CellHookData,
+  Column: Column,
+  HookData: HookData,
+  Row: Row,
+  Table: Table,
+  __createTable: __createTable,
+  __drawTable: __drawTable,
+  applyPlugin: applyPlugin,
+  autoTable: autoTable,
+  default: autoTable
+});
+
 export { AbandonedDonationRecovery, Dashboard, theme as DashboardTheme, DonorBehavior, MetricSelector, NewOverview, PerformanceSection, RecurringRevenueSection, RevenueChart, UTMPerformance, themeColors, themeTypography };
 //# sourceMappingURL=index.es.js.map