@paprize/core 0.0.9 → 0.0.11

package/dist/paprize-core.js

@@ -0,0 +1,1492 @@
+const fe = "paprize", _e = "pz-temp-container", at = "pz-current-element", lt = "pz-current-text", ct = "pz-ignored-element", dt = "pz-ignored-text", Y = "paprize-global-style", z = "pz-page", ve = "pz-section", T = "pz-preview", C = "data-pz-";
+let re = !1;
+const gt = () => {
+  re = !0;
+}, q = () => re;
+function se(i) {
+  return i.nodeType === Node.ELEMENT_NODE;
+}
+function be(i) {
+  return i.nodeType === Node.TEXT_NODE;
+}
+function B(i) {
+  const e = i.getBoundingClientRect(), t = getComputedStyle(i), n = parseFloat(t.marginTop) || 0, o = parseFloat(t.marginBottom) || 0;
+  return e.height + n + o;
+}
+function ye(i) {
+  i.style.visibility = "hidden", i.style.position = "absolute", i.style.left = "-9999px", i.style.top = "-9999px";
+}
+const ae = {
+  hyphen: "-",
+  keepOnSamePage: !1,
+  hyphenationDisabled: !1
+}, we = `${C}hyphen`, xe = `${C}keep-on-same-page`, Ne = `${C}hyphenation-disabled`, le = {
+  hyphen: {
+    key: we,
+    reader: (i) => String(i)
+  },
+  keepOnSamePage: {
+    key: xe,
+    reader: (i) => i === "true"
+  },
+  hyphenationDisabled: {
+    key: Ne,
+    reader: (i) => i === "true"
+  }
+};
+function pt(i) {
+  const e = {};
+  for (const [t, n] of Object.entries(i)) {
+    const o = le[t];
+    o !== void 0 && n !== void 0 && (e[o.key] = String(n));
+  }
+  return e;
+}
+const Q = /* @__PURE__ */ new WeakMap();
+function Se(i, e, t, n) {
+  if (t == null)
+    return;
+  const o = e(t);
+  o !== void 0 && (n[i] = o);
+}
+function ce(i) {
+  if (!i)
+    return {};
+  if (!(i instanceof Element))
+    return ce(i?.parentNode);
+  const e = {};
+  for (const o of Object.keys(ae)) {
+    const r = o, s = le[r], c = i.getAttribute(s.key);
+    Se(r, s.reader, c, e);
+  }
+  const n = { ...i.parentNode ? Q.get(i.parentNode) : void 0, ...e };
+  return Q.set(i, n), n;
+}
+const de = {
+  id: "default",
+  plugins: [],
+  ...ae
+};
+function Ce(i, e) {
+  const t = ce(i);
+  return { ...de, ...e, ...t };
+}
+function Pe(i) {
+  return i && i.__esModule && Object.prototype.hasOwnProperty.call(i, "default") ? i.default : i;
+}
+var $ = { exports: {} }, Ee = $.exports, ee;
+function Te() {
+  return ee || (ee = 1, (function(i) {
+    (function(e, t) {
+      i.exports ? i.exports = t() : e.log = t();
+    })(Ee, function() {
+      var e = function() {
+      }, t = "undefined", n = typeof window !== t && typeof window.navigator !== t && /Trident\/|MSIE /.test(window.navigator.userAgent), o = [
+        "trace",
+        "debug",
+        "info",
+        "warn",
+        "error"
+      ], r = {}, s = null;
+      function c(l, p) {
+        var a = l[p];
+        if (typeof a.bind == "function")
+          return a.bind(l);
+        try {
+          return Function.prototype.bind.call(a, l);
+        } catch {
+          return function() {
+            return Function.prototype.apply.apply(a, [l, arguments]);
+          };
+        }
+      }
+      function _() {
+        console.log && (console.log.apply ? console.log.apply(console, arguments) : Function.prototype.apply.apply(console.log, [console, arguments])), console.trace && console.trace();
+      }
+      function w(l) {
+        return l === "debug" && (l = "log"), typeof console === t ? !1 : l === "trace" && n ? _ : console[l] !== void 0 ? c(console, l) : console.log !== void 0 ? c(console, "log") : e;
+      }
+      function f() {
+        for (var l = this.getLevel(), p = 0; p < o.length; p++) {
+          var a = o[p];
+          this[a] = p < l ? e : this.methodFactory(a, l, this.name);
+        }
+        if (this.log = this.debug, typeof console === t && l < this.levels.SILENT)
+          return "No console available for logging";
+      }
+      function v(l) {
+        return function() {
+          typeof console !== t && (f.call(this), this[l].apply(this, arguments));
+        };
+      }
+      function M(l, p, a) {
+        return w(l) || v.apply(this, arguments);
+      }
+      function G(l, p) {
+        var a = this, O, W, x, m = "loglevel";
+        typeof l == "string" ? m += ":" + l : typeof l == "symbol" && (m = void 0);
+        function ue(d) {
+          var u = (o[d] || "silent").toUpperCase();
+          if (!(typeof window === t || !m)) {
+            try {
+              window.localStorage[m] = u;
+              return;
+            } catch {
+            }
+            try {
+              window.document.cookie = encodeURIComponent(m) + "=" + u + ";";
+            } catch {
+            }
+          }
+        }
+        function Z() {
+          var d;
+          if (!(typeof window === t || !m)) {
+            try {
+              d = window.localStorage[m];
+            } catch {
+            }
+            if (typeof d === t)
+              try {
+                var u = window.document.cookie, H = encodeURIComponent(m), X = u.indexOf(H + "=");
+                X !== -1 && (d = /^([^;]+)/.exec(
+                  u.slice(X + H.length + 1)
+                )[1]);
+              } catch {
+              }
+            return a.levels[d] === void 0 && (d = void 0), d;
+          }
+        }
+        function he() {
+          if (!(typeof window === t || !m)) {
+            try {
+              window.localStorage.removeItem(m);
+            } catch {
+            }
+            try {
+              window.document.cookie = encodeURIComponent(m) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+            } catch {
+            }
+          }
+        }
+        function E(d) {
+          var u = d;
+          if (typeof u == "string" && a.levels[u.toUpperCase()] !== void 0 && (u = a.levels[u.toUpperCase()]), typeof u == "number" && u >= 0 && u <= a.levels.SILENT)
+            return u;
+          throw new TypeError("log.setLevel() called with invalid level: " + d);
+        }
+        a.name = l, a.levels = {
+          TRACE: 0,
+          DEBUG: 1,
+          INFO: 2,
+          WARN: 3,
+          ERROR: 4,
+          SILENT: 5
+        }, a.methodFactory = p || M, a.getLevel = function() {
+          return x ?? W ?? O;
+        }, a.setLevel = function(d, u) {
+          return x = E(d), u !== !1 && ue(x), f.call(a);
+        }, a.setDefaultLevel = function(d) {
+          W = E(d), Z() || a.setLevel(d, !1);
+        }, a.resetLevel = function() {
+          x = null, he(), f.call(a);
+        }, a.enableAll = function(d) {
+          a.setLevel(a.levels.TRACE, d);
+        }, a.disableAll = function(d) {
+          a.setLevel(a.levels.SILENT, d);
+        }, a.rebuild = function() {
+          if (s !== a && (O = E(s.getLevel())), f.call(a), s === a)
+            for (var d in r)
+              r[d].rebuild();
+        }, O = E(
+          s ? s.getLevel() : "WARN"
+        );
+        var K = Z();
+        K != null && (x = E(K)), f.call(a);
+      }
+      s = new G(), s.getLogger = function(p) {
+        if (typeof p != "symbol" && typeof p != "string" || p === "")
+          throw new TypeError("You must supply a name when creating a logger.");
+        var a = r[p];
+        return a || (a = r[p] = new G(
+          p,
+          s.methodFactory
+        )), a;
+      };
+      var pe = typeof window !== t ? window.log : void 0;
+      return s.noConflict = function() {
+        return typeof window !== t && window.log === s && (window.log = pe), s;
+      }, s.getLoggers = function() {
+        return r;
+      }, s.default = s, s;
+    });
+  })($)), $.exports;
+}
+var ke = Te();
+const S = /* @__PURE__ */ Pe(ke), g = S.getLogger(fe);
+g.setDefaultLevel("info");
+const U = "\x1B[46mPLUGIN\x1B[0m";
+function y(i, e, ...t) {
+  i.sort((n, o) => n.order - o.order).forEach((n) => {
+    const o = n[e];
+    if (o) {
+      g.debug(
+        U,
+        `executing plugin ${n.name}:${String(e)} ()`,
+        t
+      );
+      try {
+        o(...t), g.debug(
+          U,
+          `plugin ${n.name}:${String(e)} executed`,
+          t
+        );
+      } catch (r) {
+        g.debug(
+          U,
+          `plugin ${n.name}:${String(e)} failed`,
+          r
+        );
+      }
+    }
+  });
+}
+const P = {
+  Element: "element",
+  Text: "text"
+};
+class F {
+  _node;
+  config;
+  type = P.Element;
+  transaction;
+  clonedFrom;
+  cloneCount;
+  constructor(e, t, n, o) {
+    this._node = e, this.transaction = t, this.config = n, this.clonedFrom = o, this.cloneCount = o ? o.cloneCount + 1 : 0;
+  }
+  getOriginalNode() {
+    let e = this.clonedFrom;
+    for (; e?.clonedFrom; )
+      e = e.clonedFrom;
+    return e?._node;
+  }
+  appendChild(e) {
+    this.transaction.isActive && this.transaction.addRollbackCallback(() => {
+      this._node.removeChild(e.getNode());
+    }), this._node.appendChild(e.getNode());
+  }
+  clone(e) {
+    const t = this._node.cloneNode(e), n = new F(
+      t,
+      this.transaction,
+      this.config,
+      this
+    );
+    return y(
+      this.config.plugins,
+      "onClone",
+      this.config.id,
+      this._node,
+      n
+    ), n;
+  }
+  getHeight() {
+    return B(this._node);
+  }
+  remove() {
+    this.transaction.addCommitCallback(() => {
+      this._node.remove();
+    });
+  }
+  isEmpty() {
+    return this._node.innerHTML === "";
+  }
+  getChildrenCount() {
+    return this._node.childNodes.length;
+  }
+  getNode() {
+    return this._node;
+  }
+}
+class Ae {
+  _node;
+  type = P.Text;
+  transaction;
+  config;
+  constructor(e, t, n) {
+    this._node = e, this.transaction = t, this.config = n;
+  }
+  get textContent() {
+    return this._node.textContent ?? "";
+  }
+  set textContent(e) {
+    this._node.textContent = e;
+  }
+  remove() {
+    this.transaction.addCommitCallback(() => {
+      this._node.remove();
+    });
+  }
+  getNode() {
+    return this._node;
+  }
+}
+function D(i, e, t) {
+  if (be(i))
+    return new Ae(i, e, t);
+  if (se(i))
+    return new F(i, e, t);
+  throw new Error("Unsupported node type");
+}
+const k = "\x1B[106mDOM\x1B[0m";
+class Ie {
+  _transaction;
+  _treeWalker;
+  _config;
+  _completed = !1;
+  _currentNode = null;
+  _previousNode = null;
+  constructor(e, t, n) {
+    this._transaction = t, this._config = n, this._treeWalker = document.createTreeWalker(
+      e,
+      NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT
+    );
+  }
+  get completed() {
+    return this._completed;
+  }
+  get currentNode() {
+    return this._currentNode;
+  }
+  get previousNode() {
+    return this._previousNode;
+  }
+  goToNextNode() {
+    this._treeWalker.nextNode() || (this._completed = !0), g.debug(k, "moving to next node"), this.setState();
+  }
+  goToNextSiblingOrParentSibling() {
+    let e = 0;
+    if (this._treeWalker.nextSibling())
+      return g.debug(k, "moving to next sibling node"), this.setState(), { parentsTraversed: e };
+    for (; this._treeWalker.parentNode(); )
+      if (e++, this._treeWalker.nextSibling())
+        return g.debug(
+          k,
+          "moving to parent sibling node, traversed:",
+          e
+        ), this.setState(), { parentsTraversed: e };
+    return this._completed = !0, { parentsTraversed: e };
+  }
+  goToFirstChildOrNextNode() {
+    return this._treeWalker.firstChild() ? (g.debug(k, "moving to first child node"), this.setState(), { parentsTraversed: 1 }) : (this.goToNextNode(), { parentsTraversed: 0 });
+  }
+  setState() {
+    this._previousNode = this._currentNode, this._currentNode = D(
+      this._treeWalker.currentNode,
+      this._transaction,
+      Ce(this._treeWalker.currentNode, this._config)
+    ), g.debug(k, "moved to node", {
+      currentNode: this._currentNode,
+      previousNode: this._previousNode
+    });
+  }
+}
+class Fe {
+  _onRollback;
+  _onCommit;
+  isActive;
+  constructor() {
+    this._onRollback = [], this._onCommit = [], this.isActive = !1;
+  }
+  start = () => {
+    if (this.isActive)
+      throw new Error("Transaction already in progress");
+    this.isActive = !0, this._onRollback = [], this._onCommit = [];
+  };
+  addRollbackCallback = (e) => {
+    this._onRollback.push(e);
+  };
+  addCommitCallback = (e) => {
+    if (!this.isActive) {
+      e();
+      return;
+    }
+    this._onCommit.push(e);
+  };
+  rollback = () => {
+    this.isActive && (this.isActive = !1, this._onRollback.forEach((e) => e()));
+  };
+  commit = () => {
+    this.isActive && (this.isActive = !1, this._onCommit.forEach((e) => e()));
+  };
+}
+const V = "\x1B[102mPAGE\x1B[0m";
+class L {
+  currentPage;
+  activeElement;
+  currentElement;
+  parentStack;
+  pageIsFull;
+  pageIndex;
+  pageHeight;
+  constructor(e, t, n, o, r, s, c) {
+    this.currentPage = e, this.activeElement = t, this.currentElement = n, this.parentStack = o, this.pageIsFull = r, this.pageIndex = s, this.pageHeight = c;
+  }
+  static create(e, t, n, o) {
+    return new L(
+      e,
+      null,
+      e,
+      t,
+      !1,
+      n,
+      o
+    );
+  }
+  clone = () => new L(
+    this.currentPage,
+    this.activeElement,
+    this.currentElement,
+    [...this.parentStack],
+    this.pageIsFull,
+    this.pageIndex,
+    this.pageHeight
+  );
+}
+class J {
+  _pageState;
+  _transaction;
+  _tempContainer;
+  _config;
+  constructor(e, t, n, o) {
+    this._tempContainer = e, this._config = o, this._transaction = n;
+    const r = J.createPageHtmlElement(
+      t.width
+    ), s = this.createNewPage(r);
+    this._pageState = L.create(s, [], 0, t.height), y(this._config.plugins, "onNewPage", o.id, this);
+  }
+  nextPage() {
+    const e = this.createNewPage(
+      this._pageState.currentPage.getNode().cloneNode(!1)
+    ), t = L.create(
+      e,
+      [],
+      this._pageState.pageIndex + 1,
+      this._pageState.pageHeight
+    );
+    this.cloneParentStackToNewPage(t), this.cleanupEmptyParent(), this._pageState = t, y(
+      this._config.plugins,
+      "onNewPage",
+      this._config.id,
+      this
+    );
+  }
+  cloneParentStackToNewPage(e) {
+    for (const t of this._pageState.parentStack) {
+      const n = t.clone(!1);
+      e.currentElement.appendChild(n), e.currentElement = n, e.parentStack.push(n);
+    }
+  }
+  cleanupEmptyParent() {
+    const e = [...this._pageState.parentStack], t = () => {
+      for (let n = e.length - 1; n >= 0; n--) {
+        const o = e[n];
+        o.isEmpty() && o.remove();
+      }
+    };
+    this._transaction.addCommitCallback(t);
+  }
+  enterElement() {
+    if (!this._pageState.activeElement || this._pageState.activeElement.type !== P.Element)
+      throw new Error("Invalid state: activeElement is not an Element");
+    g.debug(
+      V,
+      "entering an element",
+      this._pageState.activeElement
+    ), this._pageState.currentElement = this._pageState.activeElement, this._pageState.parentStack.push(this._pageState.activeElement);
+  }
+  leaveElement() {
+    this._pageState.activeElement = null;
+    const e = this._pageState.parentStack.pop();
+    g.debug(V, "leaving a parent element", e);
+    const t = this._pageState.parentStack.at(-1);
+    this._pageState.currentElement = t ?? this._pageState.currentPage;
+  }
+  static createPageHtmlElement(e) {
+    const t = document.createElement("div");
+    return t.style.width = `${e}px`, t.style.maxWidth = `${e}px`, t.className = z, t;
+  }
+  createNewPage(e) {
+    return g.debug(V, "creating new page"), this._tempContainer.appendChild(e), this._transaction.isActive && this._transaction.addRollbackCallback(() => {
+      this._tempContainer.removeChild(e);
+    }), D(e, this._transaction, this._config);
+  }
+  startTransaction() {
+    this._transaction.start();
+    const e = this._pageState.clone();
+    return this._transaction.addRollbackCallback(() => {
+      this._pageState = e;
+    }), this._transaction;
+  }
+  hasEmptySpace(e) {
+    return !this._pageState.pageIsFull && this._pageState.currentPage.getHeight() + (e || 1e-4) <= this._pageState.pageHeight;
+  }
+  isOverFlow() {
+    return this._pageState.currentPage.getHeight() > this._pageState.pageHeight;
+  }
+  markPageAsFull() {
+    this._pageState.pageIsFull = !0;
+  }
+  appendChild(e, t) {
+    const n = e.clone(t);
+    return this._pageState.currentElement.appendChild(n), this._pageState.activeElement = n, n;
+  }
+  addTextNode(e) {
+    if (this._pageState.activeElement?.type === P.Text)
+      return this._pageState.activeElement;
+    const t = document.createTextNode(e), n = D(
+      t,
+      this._transaction,
+      this._config
+    );
+    return this._pageState.currentElement.appendChild(n), this._pageState.activeElement = n, n;
+  }
+  getPageState() {
+    return this._pageState;
+  }
+}
+const h = {
+  None: 0,
+  // The node fits completely on the page, no further splitting required.
+  FullNodePlaced: 1,
+  // The entire node was placed on the page, continue with the next sibling or element.
+  SplitChildren: 2
+  // The node is too large for the page, and its children must be paginated individually.
+};
+function Le(i, e) {
+  const t = te(i, e);
+  if (t !== h.None)
+    return t;
+  const { rollback: n, commit: o } = e.startTransaction();
+  e.nextPage();
+  const r = te(i, e);
+  return r !== h.None ? (o(), r) : (n(), g.debug("Element is too big to fit on a page", i), h.None);
+}
+function te(i, e) {
+  if (e.hasEmptySpace(i.getHeight())) {
+    const n = e.appendChild(i, !0);
+    if (e.isOverFlow())
+      n.remove();
+    else
+      return h.FullNodePlaced;
+  }
+  if (i.config.keepOnSamePage || i.getChildrenCount() === 0)
+    return h.None;
+  const t = e.appendChild(i, !1);
+  return e.isOverFlow() ? (t.remove(), h.None) : h.SplitChildren;
+}
+function Re(i, e) {
+  let t = h.FullNodePlaced;
+  const n = i.textContent.split(/(\s+)/).filter((s) => s !== "");
+  let o, r = 0;
+  for (; o || r < n.length; ) {
+    const s = o ?? n[r], c = Oe(s, e, i.config);
+    c.completed || (t = h.None), c.pendingToken ? o = c.pendingToken : (o = void 0, r++);
+  }
+  return t;
+}
+function Oe(i, e, t) {
+  const n = e.addTextNode(""), o = n.textContent;
+  if (n.textContent += i, !e.isOverFlow())
+    return {
+      completed: !0
+    };
+  n.textContent = o;
+  const r = He(i, e, t);
+  return {
+    pendingToken: r.leftovers,
+    completed: r.completed
+  };
+}
+function He(i, e, t) {
+  const { rollback: n, commit: o } = e.startTransaction();
+  if (e.nextPage(), e.addTextNode(i), !e.isOverFlow())
+    return o(), {
+      completed: !0
+    };
+  if (n(), t.hyphenationDisabled)
+    return g.warn("Hyphenation disabled, skipping oversized token:", i), {
+      completed: !1
+    };
+  e.hasEmptySpace() || e.nextPage();
+  const r = $e(i, t.hyphen, e);
+  return {
+    completed: !0,
+    leftovers: r && r.length > 0 ? r : void 0
+  };
+}
+function $e(i, e, t) {
+  const n = t.addTextNode("");
+  let o = "";
+  for (let r = 0; r < i.length; r++) {
+    const s = i[r], c = o + s;
+    if (n.textContent = c + e, !t.hasEmptySpace())
+      return n.textContent = o ? o + e : "", t.markPageAsFull(), i.slice(r);
+    o = c;
+  }
+  return null;
+}
+const A = "\x1B[103mPAGINATOR\x1B[0m";
+class j {
+  _domState;
+  _pageManager;
+  _transaction;
+  _tempContainer;
+  _config;
+  constructor(e, t, n) {
+    this._config = { ...de, ...n }, this._tempContainer = j.createTempContainer(this._config.id), this._transaction = new Fe(), this._domState = new Ie(e, this._transaction, this._config), this._pageManager = new J(
+      this._tempContainer,
+      t,
+      this._transaction,
+      this._config
+    );
+  }
+  static createTempContainer(e) {
+    const t = document.createElement("div");
+    return t.style.display = "flex", t.style.flexDirection = "column", t.style.gap = "20px", t.setAttribute(`${C}-section-id`, e), t.classList.add(_e), q() || ye(t), document.body.appendChild(t), t;
+  }
+  static paginate(e, t, n) {
+    const o = new j(e, t, n);
+    o.processAllNodes();
+    const r = Array.from(o._tempContainer.childNodes).filter((s) => se(s)).map((s) => s.innerHTML);
+    return q() ? Array.from(o._tempContainer.childNodes).forEach((s) => {
+      const c = s;
+      c.style.height = `${t.height}px`, c.style.width = `${t.width}px`;
+    }) : o._tempContainer.remove(), r;
+  }
+  processAllNodes() {
+    this._domState.goToNextNode();
+    do {
+      S.debug(
+        A,
+        "paginating node",
+        this._domState.currentNode
+      );
+      const e = this.processCurrentNode();
+      switch (y(
+        this._config.plugins,
+        "afterVisitNode",
+        this._config.id,
+        e,
+        this._domState,
+        this._pageManager
+      ), e) {
+        case h.None:
+          this.handleNodeSkipped();
+          break;
+        case h.FullNodePlaced:
+          this.handleFullNodePlaced();
+          break;
+        case h.SplitChildren:
+          this.handleChildrenSplit();
+          break;
+      }
+    } while (this._domState.completed === !1);
+    y(
+      this._config.plugins,
+      "afterPagination",
+      this._config.id,
+      this._domState,
+      this._pageManager
+    ), S.debug(A, "pagination completed");
+  }
+  handleNodeSkipped() {
+    S.debug(A, "node skipped - couldn't paginate"), this._domState.goToNextNode();
+  }
+  handleFullNodePlaced() {
+    S.debug(A, "node fully paginated");
+    const { parentsTraversed: e } = this._domState.goToNextSiblingOrParentSibling();
+    for (let t = 0; t < e; t++)
+      this._pageManager.leaveElement();
+  }
+  handleChildrenSplit() {
+    S.debug(
+      A,
+      "node partially paginated - splitting children"
+    ), this._domState.goToFirstChildOrNextNode().parentsTraversed === 1 && this._domState.previousNode?.type === P.Element && this._pageManager.enterElement();
+  }
+  processCurrentNode() {
+    if (!this._domState.currentNode)
+      return h.None;
+    if (this._domState.currentNode.type === P.Element) {
+      const e = {};
+      return y(
+        this._config.plugins,
+        "onVisitElement",
+        this._config.id,
+        this._domState,
+        this._pageManager,
+        e
+      ), e.result !== void 0 ? e.result : Le(
+        this._domState.currentNode,
+        this._pageManager
+      );
+    } else {
+      const e = {};
+      return y(
+        this._config.plugins,
+        "onVisitText",
+        this._config.id,
+        this._domState,
+        this._pageManager,
+        e
+      ), e.result !== void 0 ? e.result : Re(
+        this._domState.currentNode,
+        this._pageManager
+      );
+    }
+  }
+}
+class ge {
+  registry = /* @__PURE__ */ new Map();
+  addEventListener(e, t) {
+    const { registry: n } = this, o = new Set(n.get(e));
+    return o.add(t), n.set(e, o), () => this.removeEventListener(e, t);
+  }
+  removeEventListener(e, t) {
+    const { registry: n } = this, o = new Set(n.get(e));
+    o.delete(t), n.set(e, o);
+  }
+  async dispatch(e, ...t) {
+    const { registry: n } = this, o = n.get(e);
+    if (o)
+      for (const r of o)
+        await r(...t);
+  }
+}
+const ut = {
+  /** 841mm x 594mm */
+  A1: { height: "841mm", width: "594mm" },
+  /** 594mm x 420mm */
+  A2: { height: "594mm", width: "420mm" },
+  /** 420mm x 297mm */
+  A3: { height: "420mm", width: "297mm" },
+  /** 297mm x 210mm */
+  A4: { height: "297mm", width: "210mm" },
+  /** 210mm x 148mm */
+  A5: { height: "210mm", width: "148mm" },
+  /** 148mm x 105mm */
+  A6: { height: "148mm", width: "105mm" },
+  /** 500mm x 353mm */
+  B3: { height: "500mm", width: "353mm" },
+  /** 353mm x 250mm */
+  B4: { height: "353mm", width: "250mm" },
+  /** 250mm x 176mm */
+  B5: { height: "250mm", width: "176mm" },
+  /** 8.5in x 11in */
+  Letter: { height: "8.5in", width: "11in" },
+  /** 11in x 8.5in */
+  Legal: { height: "11in", width: "8.5in" },
+  /** 11in x 17in */
+  Tabloid: { height: "11in", width: "17in" }
+}, ze = {
+  /** Top, Right, Bottom, Left: 1in */
+  Normal: {
+    top: "1in",
+    right: "1in",
+    bottom: "1in",
+    left: "1in"
+  },
+  /** Top: 0.4in, Right, Bottom, Left: 0.6in */
+  Narrow: {
+    top: "0.4in",
+    right: "0.6in",
+    bottom: "0.6in",
+    left: "0.6in"
+  },
+  /** Top, Bottom: 0.5in, Right, Left: 2in */
+  Wide: {
+    top: "0.5in",
+    right: "2in",
+    bottom: "0.5in",
+    left: "2in"
+  },
+  /** Top, Right, Bottom, Left: 0 */
+  None: {
+    top: "0in",
+    right: "0in",
+    bottom: "0in",
+    left: "0in"
+  }
+}, Be = "__PAPRIZE_IS_INITIALIZED", ne = "__PAPRIZE_IS_READY", ie = "__PAPRIZE_READ_JSON_DATA_FILE";
+function De(i) {
+  const e = i.getBoundingClientRect(), t = getComputedStyle(i), n = parseFloat(t.marginLeft) || 0, o = parseFloat(t.marginRight) || 0;
+  return {
+    height: B(i),
+    width: e.width + n + o
+  };
+}
+function je(i, e, t) {
+  const { height: n, width: o } = De(i), r = e ? B(e) : 0, s = t ? B(t) : 0;
+  return { height: n, width: o, sectionHeaderHeight: r, sectionFooterHeight: s };
+}
+function Me(i, e, t) {
+  return {
+    name: "sectionPageHeight",
+    order: 1,
+    afterPagination: (n, o, r) => {
+      t <= 0 || r.hasEmptySpace(t) || r.nextPage();
+    },
+    onNewPage: (n, o) => {
+      const r = o.getPageState();
+      r.pageIndex === 0 ? r.pageHeight = i + t : r.pageHeight = i + e + t;
+    }
+  };
+}
+function We(i) {
+  return i ? `${i.top} ${i.right} ${i.bottom} ${i.left}` : "0";
+}
+function Ue(i) {
+  let e = null;
+  return () => (e || (e = i()), e);
+}
+async function Ve() {
+  if (!(ie in window))
+    return null;
+  const i = await window[ie]?.();
+  return i ? JSON.parse(i) : null;
+}
+const qe = `
+    html {
+        box-sizing: border-box;
+    }
+
+    *,
+    *:before,
+    *:after {
+        box-sizing: inherit;
+    }
+
+    :root {
+        --paprize-page-background-color: #ffffff;
+        --paprize-page-box-shadow: rgb(142 138 138) -1px 3px 5px 2px;
+        --paprize-section-margin-bottom: 10px;
+        --paprize-preview-background-color: rgb(218 220 224);
+        --paprize-preview-padding: 30px 10px;
+    }
+
+    body {
+        margin: 0;
+    }
+    
+    @media screen {
+        .${T} {
+            min-height: 100vh;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            background-color: var(--paprize-preview-background-color);
+            padding: var(--paprize-preview-padding);
+        }
+
+        .${z} {
+            box-shadow: var(--paprize-page-box-shadow);
+            background-color: var(--paprize-page-background-color);
+        }
+
+        .${ve} {
+            margin-bottom: var(--paprize-section-margin-bottom);
+        }
+    }
+
+    @media print {
+        html:has(.${T}) *:not(.${T}):not(.${T} *):not(:has(.${T})) {
+            display: none !important;
+        }
+    }   
+ `, Je = {
+  display: "flex",
+  flexDirection: "column"
+}, Ge = {
+  position: "absolute",
+  left: "-9999px",
+  top: "-9999px",
+  visibility: "hidden"
+}, Ze = (i, e) => ({
+  display: "flex",
+  flexDirection: "column",
+  width: i.width,
+  height: i.height,
+  maxHeight: i.height,
+  position: "relative",
+  padding: We(e),
+  zIndex: "1"
+}), Ke = {
+  overflow: "hidden",
+  width: "100%",
+  height: "100%"
+}, Xe = {
+  position: "absolute",
+  width: "100%",
+  height: "100%",
+  left: 0,
+  top: 0
+}, Ye = (i) => ({
+  page: `section-${i}`
+});
+function Qe(i, e) {
+  return `@page section-${i} {
+      margin: none; 
+      size:${e.width} ${e.height}; 
+      width:${e.width};
+      height:${e.height};
+    }`;
+}
+const b = {
+  globalStyle: qe,
+  component: Je,
+  outOfScreen: Ge,
+  page: Ze,
+  overlay: Xe,
+  pageContent: Ke,
+  sectionPageMedia: Qe,
+  section: Ye
+};
+function I(i) {
+  return i?.cloneNode(!0) ?? null;
+}
+function et(i) {
+  return {
+    sectionHeader: I(i.sectionHeader),
+    sectionFooter: I(i.sectionFooter),
+    pageHeader: I(i.pageHeader),
+    pageFooter: I(i.pageFooter),
+    pageContent: I(i.pageContent)
+  };
+}
+const tt = "data-pz-page-break";
+class nt {
+  name = "pageBreak";
+  order = 1;
+  onVisitElement = (e, t, n, o) => {
+    t.currentNode.getNode().getAttribute(tt) === "true" && (n.markPageAsFull(), o.result = h.FullNodePlaced);
+  };
+}
+class it {
+  _options = {};
+  name = "table";
+  order = 1;
+  constructor(e = {}) {
+    this._options = e;
+  }
+  onNewPage = (e, t) => {
+    if (this._options.includeHeaderOnlyTables)
+      return;
+    const o = t.getPageState().parentStack.find(
+      (v) => this._isTable(v.getNode())
+    );
+    if (!o || !o.clonedFrom)
+      return;
+    const r = o.clonedFrom, s = r.getNode(), c = s.tHead;
+    if (!(c !== null))
+      return;
+    const w = s.tBodies;
+    if (!this._isTableBodyEmpty(w))
+      return;
+    if (r.remove(), o.getNode().tHead === null) {
+      const v = D(
+        c.cloneNode(!0),
+        o.transaction,
+        o.config
+      );
+      o.appendChild(v);
+    }
+  };
+  onVisitElement = (e, t, n, o) => {
+    const r = t.currentNode.getNode();
+    r.tagName === "TR" ? t.currentNode.config.keepOnSamePage = !0 : (r.tagName === "TFOOT" && this._options.cloneFooter || r.tagName === "THEAD" && this._options.cloneHeader) && (o.result = h.FullNodePlaced);
+  };
+  onClone = (e, t, n) => {
+    if (!this._isTable(t) || !n.clonedFrom)
+      return;
+    const o = n.getNode();
+    if (o.tHead || o.tFoot)
+      return;
+    const r = n.getOriginalNode(), s = r.tHead;
+    if (s && this._options.cloneHeader === !0) {
+      const _ = new F(
+        s.cloneNode(!0),
+        n.transaction,
+        n.config
+      );
+      n.appendChild(_);
+    }
+    const c = r.tFoot;
+    if (c && this._options.cloneFooter === !0) {
+      const _ = new F(
+        c.cloneNode(!0),
+        n.transaction,
+        n.config
+      );
+      n.appendChild(_);
+    }
+  };
+  _isTable(e) {
+    return e.tagName === "TABLE";
+  }
+  _isTableBodyEmpty(e) {
+    if (e.length === 0) return !0;
+    const t = e[0];
+    if (t.rows.length === 0) return !0;
+    if (t.rows.length > 1) return !1;
+    const n = t.rows[0];
+    return n.cells.length === 0 ? !0 : n.cells.length > 1 ? !1 : n.cells[0].textContent?.trim().length === 0;
+  }
+}
+const ot = [
+  new nt(),
+  new it()
+], ht = {
+  name: "debug",
+  order: Number.MAX_SAFE_INTEGER,
+  onNewPage: (i, e) => {
+    const t = e.getPageState().currentPage.getNode();
+    t.classList.contains(z) || t.classList.add(z), t.setAttribute(`${C}-element`, "page"), t.setAttribute(
+      `${C}-height`,
+      e.getPageState().pageHeight.toString()
+    );
+  }
+}, rt = "sectionToc";
+class mt {
+  name = rt;
+  order = 1;
+  _state = /* @__PURE__ */ new Map();
+  getContentList = () => Array.from(this._state.values()).flat();
+  onVisitElement = (e, t, n) => {
+    {
+      const o = t.currentNode.getNode(), r = this.getHeadingLevel(o);
+      if (!r || !o.textContent) return;
+      const s = n.getPageState().pageIndex;
+      s === 0 && this._state.set(e, []), this._state.get(e)?.push({
+        sectionId: e,
+        pageIndex: s,
+        title: o.textContent,
+        level: r
+      });
+    }
+  };
+  getHeadingLevel(e) {
+    const t = e.tagName;
+    return /^H[1-6]$/.test(t) ? parseInt(t.charAt(1), 10) : null;
+  }
+}
+class R {
+  _promises;
+  monitor;
+  constructor() {
+    this._promises = [], this.monitor = new ge();
+  }
+  toPromise() {
+    return this._promises.length > 0 ? Promise.allSettled(this._promises.map((e) => e.promise)).then(
+      (e) => {
+        const t = e.find(
+          (n) => n.status === "rejected"
+        );
+        return t ? Promise.reject(t.reason) : Promise.resolve();
+      }
+    ) : Promise.resolve();
+  }
+  then(e) {
+    this._promises.push(
+      R.toTracked(this.toPromise().then(e))
+    );
+  }
+  async add(e = []) {
+    if (this._promises.push(...e.map(R.toTracked)), await new Promise((t) => setTimeout(t, 0)), this.getPending().length === 0) {
+      this.monitor.dispatch("onChange", 0);
+      return;
+    }
+    this._promises.forEach((t) => this.injectEvents(t));
+  }
+  static toTracked(e) {
+    const t = {
+      promise: e,
+      status: "pending"
+    };
+    return t.promise.then(() => {
+      t.status = "resolved";
+    }).catch(() => {
+      t.status = "rejected";
+    }), t;
+  }
+  async injectEvents(e) {
+    e.promise.finally(() => {
+      const t = this.getPending();
+      this.monitor.dispatch("onChange", t.length);
+    });
+  }
+  getPending() {
+    return Array.from(this._promises.values()).filter(
+      (e) => e.status === "pending"
+    );
+  }
+}
+function ft(i, e) {
+  return `${i}-${e + 1}`;
+}
+function st(i, e) {
+  return e === "landscape" ? { height: i.width, width: i.height } : i;
+}
+const N = "\x1B[43mREPORT\x1B[0m";
+class _t {
+  _sections;
+  _monitor;
+  _paginationInProgress;
+  _pendingPaginateResolvers;
+  _currentAbortController;
+  constructor() {
+    this._sections = /* @__PURE__ */ new Map(), this._monitor = new ge(), this._paginationInProgress = !1, this._pendingPaginateResolvers = [], this._currentAbortController = null, window[Be] = !0, this._injectStyle(b.globalStyle);
+  }
+  /**
+   * Monitor instance used to subscribe to pagination events.
+   * See {@link ReportBuilderEvents} for available event types.
+   */
+  get monitor() {
+    return this._monitor;
+  }
+  /**
+   * Removes a section from the registered sections, if it has already been registered in the report.
+   */
+  removeSection(e) {
+    this._sections.delete(e);
+  }
+  /**
+   * Registers a section by its ID, specifying the page size, margins, and other options.
+   *
+   * @param options - Configuration options for the section.
+   * @param components - The DOM components associated with the section.
+   * @param onPaginationCompleted - Callback invoked when pagination for the section is completed.
+   * @returns `true` if the section was added to the report’s section list, or `false` if it already exists.
+   */
+  async tryAddSection(e, t, n) {
+    if (this._sections.has(e.id))
+      return !1;
+    const o = {
+      sectionIndex: this._sections.size,
+      sectionId: e.id,
+      isPaginated: !1,
+      isSuspended: !!e.suspense?.length,
+      pages: [],
+      options: {
+        ...e,
+        size: st(
+          e.size,
+          e.orientation ?? "portrait"
+        )
+      },
+      components: t
+    };
+    return this._sections.set(e.id, {
+      context: o,
+      onPaginationCompleted: n
+    }), this._injectStyle(
+      b.sectionPageMedia(e.id, e.size)
+    ), await this._monitor.dispatch("sectionCreated", o), !0;
+  }
+  /**
+   * Schedules a pagination operation.
+   *
+   * It is not possible to schedule multiple pagination operations in parallel,
+   * as the process involves DOM manipulation, and concurrent modifications
+   * could cause conflicts and unexpected results.
+   * Each newly scheduled operation is queued and executed sequentially.
+   * When a new pagination is scheduled, any ongoing or pending operations
+   * will be aborted, and the new pagination will start immediately afterward.
+   *
+   * @returns A promise that resolves when the first pagination cycle is completed.
+   * It does not wait for suspended sections to resolve and be paginated.
+   * To wait for all sections to complete pagination, use the
+   * `suspension` property of the returned result object.
+   */
+  async schedulePagination() {
+    return this._sections.size === 0 ? (window[ne] = !0, {
+      sections: [],
+      suspension: Promise.resolve()
+    }) : (this._paginationInProgress && this._currentAbortController && (g.debug(
+      N,
+      "Cancelling previous pagination operation."
+    ), this._currentAbortController.abort(
+      "Cancelled by new paginate call"
+    )), this._paginationInProgress ? new Promise((e, t) => {
+      this._pendingPaginateResolvers.push({ resolve: e, reject: t });
+    }) : this._executePagination());
+  }
+  /**
+   * Retrieves JSON data injected by **@paprize/puppeteer** during server-side rendering (SSR).
+   *
+   * If no injected data is available, the function returns the provided `defaultData`, or `null` if none is given.
+   *
+   * ⚠️ **Important Notes:**
+   * - This function is **not type-safe** — it performs **no runtime type validation** on the returned data.
+   * - It is available **only during server-side rendering** when using **@paprize/puppeteer**.
+   * - When used in **client-side rendering** or **development** mode, you should provide a `defaultData` value for testing purposes.
+   *
+   * @template T - The expected type of the injected JSON data.
+   * @param defaultData - Optional fallback value to return if no injected data is found.
+   * @returns A promise resolving to the injected JSON data if available, otherwise the provided default value or `null`.
+   */
+  async getJsonData(e) {
+    return await this._lazyJsonDataReader().catch(() => e) ?? e ?? null;
+  }
+  _lazyJsonDataReader = Ue(Ve);
+  async _executePagination() {
+    this._paginationInProgress = !0, this._currentAbortController = new AbortController();
+    const e = this._currentAbortController.signal;
+    try {
+      if (g.debug(N, "Schedule paginate."), await document.fonts.ready, e.aborted)
+        return new Promise((o, r) => {
+          this._pendingPaginateResolvers.push({ resolve: o, reject: r });
+        });
+      const t = [];
+      for (const o of this._sections.values()) {
+        o.context.isPaginated = !1;
+        const r = new R();
+        await r.add(o.context.options.suspense), r.monitor.addEventListener("onChange", (s) => {
+          g.debug(
+            N,
+            `${s} pending promises in section '${o.context.sectionId}'.`
+          );
+        }), r.then(async () => {
+          e.aborted || (g.debug(
+            N,
+            `Start paginating section '${o.context.sectionId}'.`
+          ), o.context.isSuspended = !1, await this._paginateSection(o));
+        }), t.push(r);
+      }
+      const n = new R();
+      return n.monitor.addEventListener("onChange", async () => {
+        g.debug(N, "Report pagination completed."), await this._monitor.dispatch("paginationCycleCompleted", {
+          sections: [...this._sections.values()].map(
+            (o) => o.context
+          )
+        });
+      }), e.aborted ? new Promise((o, r) => {
+        this._pendingPaginateResolvers.push({ resolve: o, reject: r });
+      }) : (await n.add(t.map((o) => o.toPromise())), {
+        sections: [...this._sections.values()].map((o) => o.context),
+        suspension: n.toPromise().then(() => {
+          window[ne] = !0;
+        })
+      });
+    } finally {
+      this._processPendingPagination(), this._paginationInProgress = !1, this._currentAbortController = null;
+    }
+  }
+  async _processPendingPagination() {
+    if (this._pendingPaginateResolvers.length === 0)
+      return;
+    g.debug(
+      N,
+      `Processing ${this._pendingPaginateResolvers.length} pending paginate calls.`
+    );
+    const e = [...this._pendingPaginateResolvers];
+    this._pendingPaginateResolvers = [];
+    const t = await this._executePagination();
+    for (const n of e)
+      n.resolve(t);
+  }
+  _injectStyle(e) {
+    let t = document.getElementById(
+      Y
+    );
+    t || (t = document.createElement("style"), t.id = Y, t.textContent = "", document.head.appendChild(t)), t.textContent = (t.textContent + e).replace(/\s+/g, " ").replace(/\s*([:;{}])\s*/g, "$1").trim();
+  }
+  async _paginateSection(e) {
+    const t = document.createElement("div");
+    Object.assign(
+      t.style,
+      b.page(
+        e.context.options.size,
+        e.context.options.margin ?? ze.None
+      )
+    ), q() || Object.assign(t.style, b.outOfScreen);
+    const n = et(e.context.components);
+    n.sectionHeader && (Object.assign(
+      n.sectionHeader.style,
+      b.component
+    ), t.appendChild(n.sectionHeader)), n.pageHeader && (Object.assign(n.pageHeader.style, b.component), t.appendChild(n.pageHeader)), Object.assign(n.pageContent.style, b.pageContent), t.appendChild(n.pageContent), n.pageFooter && (Object.assign(n.pageFooter.style, b.component), t.appendChild(n.pageFooter)), n.sectionFooter && (Object.assign(
+      n.sectionFooter.style,
+      b.component
+    ), t.appendChild(n.sectionFooter)), document.body.appendChild(t);
+    const { height: o, width: r, sectionHeaderHeight: s, sectionFooterHeight: c } = je(
+      n.pageContent,
+      n.sectionHeader,
+      n.sectionFooter
+    );
+    if (o === 0)
+      throw g.error(
+        `Pagination failed for section '${e.context.sectionId}': insufficient space for page content or content is empty. Ensure that the section has content and that the header and footer do not occupy all available space.`
+      ), t.remove(), new Error(
+        `Pagination failed: no available space for content in section '${e.context.sectionId}'.`
+      );
+    const _ = j.paginate(
+      n.pageContent,
+      { height: o, width: r },
+      {
+        id: e.context.sectionId,
+        plugins: [
+          ...e.context.options.plugins ?? ot,
+          Me(
+            o,
+            s,
+            c
+          )
+        ]
+      }
+    );
+    t.remove();
+    const w = _.map((v, M) => ({
+      pageIndex: M,
+      totalPages: _.length,
+      sectionId: e.context.sectionId,
+      pageContentHtml: v
+    })), f = {
+      ...e.context,
+      isPaginated: !0,
+      isSuspended: !1,
+      pages: w
+    };
+    this._sections.set(e.context.sectionId, {
+      ...e,
+      context: f
+    }), await e.onPaginationCompleted(f);
+    for (const v of w)
+      await this._monitor.dispatch("pageCompleted", v);
+    await this._monitor.dispatch("sectionCompleted", f);
+  }
+}
+const oe = [
+  "ad",
+  "adipisicing",
+  "aliqua",
+  "aliquip",
+  "amet",
+  "anim",
+  "aute",
+  "cillum",
+  "commodo",
+  "consectetur",
+  "consequat",
+  "culpa",
+  "cupidatat",
+  "deserunt",
+  "do",
+  "dolor",
+  "dolore",
+  "duis",
+  "ea",
+  "eiusmod",
+  "elit",
+  "enim",
+  "esse",
+  "est",
+  "et",
+  "eu",
+  "ex",
+  "excepteur",
+  "exercitation",
+  "fugiat",
+  "id",
+  "in",
+  "incididunt",
+  "ipsum",
+  "irure",
+  "labore",
+  "laboris",
+  "laborum",
+  "Lorem",
+  "magna",
+  "minim",
+  "mollit",
+  "nisi",
+  "non",
+  "nostrud",
+  "nulla",
+  "occaecat",
+  "officia",
+  "pariatur",
+  "proident",
+  "qui",
+  "quis",
+  "reprehenderit",
+  "sint",
+  "sit",
+  "sunt",
+  "tempor",
+  "ullamco",
+  "ut",
+  "velit",
+  "veniam",
+  "voluptate"
+];
+function vt(i, e) {
+  if (i <= 0)
+    return "";
+  const t = [], n = Math.floor(e * 982451653);
+  for (let o = 0; o < i; o++) {
+    const r = (n + o * 2654435761) % Math.pow(2, 32), s = Math.floor(
+      r / Math.pow(2, 32) * oe.length
+    );
+    t.push(oe[s]);
+  }
+  return t.length > 0 && (t[0] = t[0].charAt(0).toUpperCase() + t[0].slice(1)), t.join(" ") + ".";
+}
+export {
+  ge as EventDispatcher,
+  nt as PageBreakPlugin,
+  j as Paginator,
+  _t as ReportBuilder,
+  mt as SectionTocPlugin,
+  h as SplitResult,
+  it as TablePlugin,
+  st as adjustPageSize,
+  C as attributePrefix,
+  ft as buildPageId,
+  et as cloneComponents,
+  vt as createLoremIpsumParagraph,
+  at as currentElementClassName,
+  lt as currentTextClassName,
+  ht as debugPlugin,
+  ot as defaultPlugins,
+  gt as enableDebugMode,
+  ce as getNodeLayoutOptionsFromAttribute,
+  B as getVisibleHeight,
+  qe as globalStyle,
+  Y as globalStyleId,
+  ct as ignoredElementClassName,
+  dt as ignoredTextClassName,
+  q as isDebugMode,
+  se as isElement,
+  be as isTextNode,
+  we as layoutOptionHyphenAttribute,
+  Ne as layoutOptionHyphenationDisabledAttribute,
+  xe as layoutOptionKeepOnSamePageAttribute,
+  pt as layoutOptionsToAttributes,
+  g as logger,
+  fe as loggerName,
+  ye as moveOffscreen,
+  tt as pageBreakAttributeName,
+  z as pageClassName,
+  ze as pageMargin,
+  ut as pageSize,
+  Be as paprize_isInitialized,
+  ne as paprize_isReady,
+  ie as paprize_readJsonDataFile,
+  T as previewClassName,
+  b as reportStyles,
+  ve as sectionClassName,
+  rt as sectionTocName,
+  _e as tempContainerClassName
+};
+//# sourceMappingURL=paprize-core.js.map