@react-pdf-kit/viewer 2.0.0-beta.0

package/dist/utils/highlight.js

@@ -0,0 +1,221 @@
+import { getCharacterType as X } from "./charators.js";
+function V(r, c, a, i) {
+  const o = [];
+  for (const n of r) {
+    const s = y(c, n, i);
+    o.push(...I(s, c, a));
+  }
+  return o;
+}
+const D = (r, c) => {
+  const a = ["g"];
+  c.matchCase || a.push("i");
+  let o = r.replace(/[.^$*+?()[{|\\]/g, (n) => `\\${n}`).trim();
+  return new RegExp(o, a.join(""));
+};
+function y(r, c, a) {
+  const i = [];
+  for (const t of r.items)
+    if (t.hasEOL)
+      if (t.str.endsWith("-")) {
+        const l = t.str.lastIndexOf("-");
+        i.push(t.str.substring(0, l));
+      } else
+        i.push(t.str, `
+`);
+    else
+      i.push(t.str);
+  const o = i.join("").replace(/\n/g, " ");
+  let n;
+  c instanceof RegExp ? n = c.flags.indexOf("g") === -1 ? new RegExp(c, `${c.flags}g`) : c : n = D(c, a);
+  const s = [];
+  let e;
+  for (; (e = n.exec(o)) !== null; )
+    a.wholeWords && !L(o, e.index, e[0].length) || s.push([e.index, e[0].length, e[0]]);
+  return s;
+}
+function I(r, c, a) {
+  function i(l) {
+    return l.hasEOL ? l.str.endsWith("-") ? -1 : 1 : 0;
+  }
+  let o = 0, n = 0;
+  const s = c.items, e = s.length - 1, t = [];
+  for (let l = 0; l < r.length; l++) {
+    let d = r[l][0];
+    for (; o !== e && d >= n + s[o].str.length; ) {
+      const f = s[o];
+      n += f.str.length + i(f), o++;
+    }
+    const p = {
+      idx: o,
+      offset: d - n
+    };
+    for (d += r[l][1]; o !== e && d > n + s[o].str.length; ) {
+      const f = s[o];
+      n += f.str.length + i(f), o++;
+    }
+    const m = {
+      idx: o,
+      offset: d - n
+    };
+    t.push({
+      start: p,
+      end: m,
+      str: r[l][2],
+      oIndex: r[l][0],
+      pageIndex: a,
+      rect: {
+        left: 0,
+        top: 0,
+        width: 0,
+        height: 0
+      }
+    });
+  }
+  for (const l of t) {
+    const d = s[l.start.idx], p = s[l.end.idx], m = d.transform[4], f = d.transform[5], E = m + d.width * l.start.offset / d.str.length, h = f, b = m + p.width * l.end.offset / p.str.length, N = f, u = {
+      left: Math.min(E, b),
+      top: Math.min(h, N),
+      width: Math.abs(b - E),
+      height: Math.max(d.height, p.height)
+    };
+    l.rect = u;
+  }
+  return t;
+}
+function L(r, c, a) {
+  let i = r.slice(0, c).match(/([^\p{M}])\p{M}*$/u);
+  if (i) {
+    const o = r.charCodeAt(c), n = i[1].charCodeAt(0);
+    if (X(o) === X(n))
+      return !1;
+  }
+  if (i = r.slice(c + a).match(/^\p{M}*([^\p{M}])/u), i) {
+    const o = r.charCodeAt(c + a - 1), n = i[1].charCodeAt(0);
+    if (X(o) === X(n))
+      return !1;
+  }
+  return !0;
+}
+function H(r, c, a) {
+  const i = [];
+  function o(n, s, e = -1, t = -1, l = "") {
+    const d = c.items[n], p = [];
+    let m = "", f = "", E = "", h = a[n];
+    if (!h)
+      return;
+    if (h.nodeType === Node.TEXT_NODE) {
+      const u = document.createElement("span");
+      h.before(u), u.append(h), a[n] = u, h = u;
+    }
+    e >= 0 && t >= 0 ? m = d.str.substring(e, t) : e < 0 && t < 0 ? m = d.str : e >= 0 ? m = d.str.substring(e) : t >= 0 && (m = d.str.substring(0, t));
+    const b = document.createTextNode(m), N = document.createElement("span");
+    if (N.className = "highlight appended " + l, N.setAttribute("data-match-index", `${s}`), N.append(b), p.push(N), i.push({ element: N, index: s }), e > 0)
+      if (h.childNodes.length === 1 && h.childNodes[0].nodeType === Node.TEXT_NODE) {
+        f = d.str.substring(0, e);
+        const u = document.createTextNode(f);
+        p.unshift(u);
+      } else {
+        let u = 0;
+        const C = [];
+        for (const g of h.childNodes) {
+          const x = g.nodeType === Node.TEXT_NODE ? g.nodeValue : g.firstChild.nodeValue;
+          u += x.length, u <= e ? C.push(g) : e >= u - x.length && t <= u && C.push(
+            document.createTextNode(
+              x.substring(0, e - (u - x.length))
+            )
+          );
+        }
+        p.unshift(...C);
+      }
+    if (t > 0) {
+      E = d.str.substring(t);
+      const u = document.createTextNode(E);
+      p.push(u);
+    }
+    h.replaceChildren(...p);
+  }
+  for (const [n, s] of r.entries())
+    if (s.start.idx === s.end.idx)
+      o(s.start.idx, n, s.start.offset, s.end.offset);
+    else
+      for (let e = s.start.idx, t = s.end.idx; e <= t; e++)
+        e === s.start.idx ? o(e, n, s.start.offset, -1, "begin") : e === s.end.idx ? o(e, n, -1, s.end.offset, "end") : o(e, n, -1, -1, "middle");
+  return i;
+}
+function R(r, c) {
+  const a = r.items.map((i) => i.str);
+  for (let i = 0; i < c.length; i++) {
+    const o = c[i];
+    if (o && o.nodeType !== Node.TEXT_NODE) {
+      const n = document.createTextNode(a[i]);
+      o.replaceChildren(n);
+    }
+  }
+}
+function W(r = {}) {
+  return { matchCase: !1, wholeWords: !1, ...r };
+}
+function A(r, c, a) {
+  const i = [];
+  function o(n, s, e = -1, t = -1, l) {
+    var u, C;
+    const d = c.items[n], p = [];
+    let m = "", f = "", E = "", h = a[n];
+    if (!h)
+      return;
+    e >= 0 && t >= 0 ? m = d.str.substring(e, t) : e < 0 && t < 0 ? m = d.str : e >= 0 ? m = d.str.substring(e) : t >= 0 && (m = d.str.substring(0, t));
+    const b = document.createTextNode(m), N = document.createElement("span");
+    if (N.style.background = l, N.append(b), p.push(N), e > 0)
+      if (h.childNodes.length === 1 && h.childNodes[0].nodeType === Node.TEXT_NODE) {
+        f = d.str.substring(0, e);
+        const g = document.createTextNode(f);
+        p.unshift(g);
+      } else {
+        let g = 0;
+        const x = [];
+        for (const T of h.childNodes) {
+          const v = T.nodeType === Node.TEXT_NODE ? T.nodeValue || "" : ((u = T.firstChild) == null ? void 0 : u.nodeValue) || "", M = v.length;
+          if (g += M, g <= e)
+            x.push(T);
+          else if (e >= g - M && t <= g) {
+            const w = v.substring(0, e - (g - M));
+            x.push(document.createTextNode(w));
+          }
+        }
+        p.unshift(...x);
+      }
+    if (t > 0)
+      if (h.childNodes.length === 1 && h.childNodes[0].nodeType === Node.TEXT_NODE) {
+        E = d.str.substring(t);
+        const g = document.createTextNode(E);
+        p.push(g);
+      } else {
+        let g = 0;
+        const x = [];
+        for (const T of h.childNodes) {
+          g >= t && x.push(T);
+          const v = T.nodeType === Node.TEXT_NODE ? T.nodeValue || "" : ((C = T.firstChild) == null ? void 0 : C.nodeValue) || "", M = v.length;
+          if (g += M, g > t) {
+            const w = v.substring(t - (g - M));
+            w && x.push(document.createTextNode(w));
+          }
+        }
+        x.length > 0 && p.push(...x);
+      }
+    h.replaceChildren(...p), i.push({ element: N, index: s });
+  }
+  for (const [n, s] of r.entries()) {
+    const { start: e, end: t, color: l } = s;
+    e.idx === t.idx && o(e.idx, n, e.offset, t.offset, l);
+  }
+  return i;
+}
+export {
+  V as findMatches,
+  W as getHighlightOptionsWithDefaults,
+  H as highlightMatches,
+  A as highlightMultipleColorMatches,
+  L as isMatchEntireWord,
+  R as resetDivs
+};

package/dist/utils/hooks/useDarkMode.js

@@ -0,0 +1,11 @@
+import { useState as t } from "react";
+const a = (e = !1) => {
+  const [o, r] = t(e);
+  return {
+    darkMode: o,
+    setDarkMode: r
+  };
+};
+export {
+  a as useDarkMode
+};

package/dist/utils/hooks/useDarkModeProps.js

@@ -0,0 +1,11 @@
+import { useDarkMode as e } from "./useDarkMode.js";
+const t = () => {
+  const { darkMode: o, setDarkMode: r } = e();
+  return {
+    darkMode: o,
+    setDarkMode: r
+  };
+};
+export {
+  t as useDarkModeProps
+};

package/dist/utils/hooks/useDebounce.js

@@ -0,0 +1,19 @@
+import { useState as i, useRef as l, useEffect as f } from "react";
+function T(t, u, r) {
+  const [c, n] = i(t), e = l(null);
+  return f(() => {
+    const o = t;
+    r && !e.current && (e.current = setTimeout(() => {
+      n(o), e.current = null;
+    }, r));
+    const s = setTimeout(() => {
+      e.current && (clearTimeout(e.current), e.current = null), n(t);
+    }, u);
+    return () => {
+      clearTimeout(s);
+    };
+  }, [t, u, r]), c;
+}
+export {
+  T as useDebounce
+};

package/dist/utils/hooks/useElementSize.js

@@ -0,0 +1,21 @@
+import { useState as a } from "react";
+import d from "./useResizeObserver.js";
+const S = (c) => {
+  const [h, u] = a({ width: 0, height: 0 });
+  return d(c, (z) => {
+    const e = z[0];
+    if (e) {
+      const t = e.contentBoxSize;
+      let i = 0, o = 0;
+      if (t) {
+        const n = Array.isArray(t) ? t : [t];
+        i = n.reduce((r, { inlineSize: s }) => r + s, 0), o = n.reduce((r, { blockSize: s }) => r + s, 0);
+      } else
+        i = e.contentRect.width, o = e.contentRect.height;
+      u({ width: i, height: o });
+    }
+  }), { size: h };
+};
+export {
+  S as default
+};

package/dist/utils/hooks/useFileDownload.js

@@ -0,0 +1,58 @@
+import "react/jsx-runtime";
+import "react";
+import "../../contexts/RPDocumentContext.js";
+import "../../contexts/DocumentPasswordContext.js";
+import { b as io } from "../../ToolbarLayout.module-c588d36b.js";
+import "../../contexts/DarkModeContext.js";
+import "../../contexts/RotationContext.js";
+import "../../contexts/LayerContext.js";
+import "../../contexts/ZoomContext.js";
+import "../../contexts/ViewModeContext.js";
+import "../../contexts/ScrollModeContext.js";
+import "../../contexts/VirtualScrollContext.js";
+import "../../contexts/VirtualGridContext.js";
+import "../../contexts/SelectionModeContext.js";
+import "../../contexts/InitialStateContext.js";
+import "../../contexts/FullScreenContext.js";
+import "../../contexts/FileInputContext.js";
+import "../../contexts/DropFileZoneContext.js";
+import "../../contexts/LayoutContainerContext.js";
+import "../../contexts/DimensionPagesContext.js";
+import "../../contexts/LocalizationContext.js";
+import "../../contexts/HighlightContext.js";
+import "../../contexts/LicenseContext.js";
+import "../../contexts/DownloadContext.js";
+import "../../contexts/SmoothScrollContext.js";
+import "../../contexts/ElementPageContext.js";
+import "../../contexts/PagesRotateContext.js";
+import "../../contexts/GlobalCurrentPage.js";
+import "../../contexts/LoaderContext.js";
+import "../../contexts/ToolComponentContext.js";
+import "../../contexts/IconToolContext.js";
+import "../../contexts/OtherToolContext.js";
+import "../../components/RPConfig.js";
+import "../../components/layout/Container.js";
+import "../../contexts/ViewportContext.js";
+import "../../contexts/ToolbarComponentContext.js";
+import "../../components/layout/sidebar/RPSplitter.js";
+import "../../components/layout/WrapperLayout.js";
+import "../../LayoutWrapper-a871c161.js";
+import "../../contexts/ThemeContext.js";
+import "../../components/RPDropFileZone.js";
+import "../../components/ui/Button.js";
+import "../../SearchCloseButton-cbf182aa.js";
+import "../../components/ui/Input.js";
+import "../../components/ui/Checkbox.js";
+import "../../components/icons/LoaderIcon.js";
+import "../../contexts/IconContext.js";
+import "../../components/ui/RPTooltip.js";
+import "../../components/ui/DropDown.js";
+import "../../ZoomTool.module-6c5eabbb.js";
+import "../../components/layout/toolbar/MenuItem.js";
+import "../../components/layout/toolbar/MenuSeparator.js";
+import "../dateFormatter.js";
+import "../../components/layout/toolbar/PropertyItem.js";
+import "../../RotateTool.module-03987eba.js";
+export {
+  io as useFileDownload
+};

package/dist/utils/hooks/useFlickerSelectText.js

@@ -0,0 +1,25 @@
+import { useRef as u, useCallback as g, useEffect as f } from "react";
+const m = () => {
+  const i = u(null), a = u(/firefox/i.test(navigator.userAgent)), o = g(() => {
+    var c, d;
+    const s = document.getSelection();
+    if (!s || s.rangeCount === 0 || a.current)
+      return;
+    const t = s.getRangeAt(0), l = i.current && (t.compareBoundaryPoints(Range.END_TO_END, i.current) === 0 || t.compareBoundaryPoints(Range.START_TO_END, i.current) === 0);
+    let e = l ? t.startContainer : t.endContainer;
+    if ((e == null ? void 0 : e.nodeType) === Node.TEXT_NODE && (e = e.parentNode), !l && t.endOffset === 0)
+      do {
+        for (; !(e != null && e.previousSibling); )
+          e = e == null ? void 0 : e.parentNode;
+        e = e.previousSibling;
+      } while (!e.childNodes.length);
+    const n = (c = e == null ? void 0 : e.parentElement) == null ? void 0 : c.closest("[data-rp-text-layer]"), r = n == null ? void 0 : n.querySelector(".endOfContent");
+    r && (r.style.width = n.style.width, r.style.height = n.style.height, (d = e == null ? void 0 : e.parentElement) == null || d.insertBefore(r, l ? e : e.nextSibling)), i.current = t.cloneRange();
+  }, []);
+  f(() => (document == null || document.addEventListener("selectionchange", o), () => {
+    document == null || document.removeEventListener("selectionchange", o);
+  }), [o]);
+};
+export {
+  m as useFlickerSelectText
+};

package/dist/utils/hooks/useFullScreen.js

@@ -0,0 +1,29 @@
+import { useState as s, useCallback as n, useEffect as a } from "react";
+const m = () => {
+  const [t, r] = s(!1), l = typeof document < "u" && (document.fullscreenEnabled || document.webkitFullscreenEnabled), c = n(async (e) => {
+    if (!document.fullscreenElement)
+      try {
+        await e.requestFullscreen();
+      } catch (o) {
+        console.error("Error attempting to enter fullscreen:", o);
+      }
+  }, []), u = n(async () => {
+    if (document.fullscreenElement)
+      try {
+        await document.exitFullscreen();
+      } catch (e) {
+        console.error("Error attempting to exit fullscreen:", e);
+      }
+  }, []);
+  return a(() => {
+    const e = () => {
+      r(!!document.fullscreenElement);
+    };
+    return document.addEventListener("fullscreenchange", e), () => {
+      document.removeEventListener("fullscreenchange", e);
+    };
+  }, []), { isFullScreen: t, enterFullScreen: c, exitFullScreen: u, isSupported: l };
+};
+export {
+  m as useFullScreen
+};

package/dist/utils/hooks/useGrabScroll.js

@@ -0,0 +1,52 @@
+import { useState as T, useRef as p, useCallback as c, useEffect as X } from "react";
+const b = ({
+  isPressed: v,
+  scrollSpeed: i = 2
+}) => {
+  const [L, f] = T("unset"), t = p(null), u = p({
+    startY: 0,
+    startX: 0,
+    startScrollTop: 0,
+    startScrollLeft: 0
+  }), o = c((r) => {
+    t.current && (u.current = {
+      startY: r.pageY,
+      startX: r.pageX,
+      startScrollTop: t.current.scrollTop,
+      startScrollLeft: t.current.scrollLeft
+    });
+  }, []), e = c(() => {
+    f("smooth");
+  }, []), s = c(
+    (r) => {
+      if (!v || !t.current)
+        return;
+      r.preventDefault(), f("unset");
+      const { startX: n, startY: a, startScrollTop: l, startScrollLeft: d } = u.current, h = (r.pageX - n) * i, w = (r.pageY - a) * i;
+      t.current.scrollTop = l - w, t.current.scrollLeft = d - h;
+    },
+    [v, i, t]
+  ), S = c(
+    (r) => {
+      var n, a, l;
+      t.current && ((n = t.current) == null || n.removeEventListener("mousedown", o), (a = t.current) == null || a.removeEventListener("mouseup", e), (l = t.current) == null || l.removeEventListener("mousemove", s)), t.current = r, r && (r == null || r.addEventListener("mousedown", o, { capture: !0 }), r == null || r.addEventListener("mouseup", e), r == null || r.addEventListener("mousemove", s));
+    },
+    [o, e, s]
+  ), E = c(() => {
+    u.current = {
+      ...u.current,
+      startScrollTop: 0,
+      startScrollLeft: 0
+    };
+  }, []);
+  return X(() => () => {
+    t.current && (t.current.removeEventListener("mousedown", o), t.current.removeEventListener("mouseup", e), t.current.removeEventListener("mousemove", s));
+  }, [o, e, s]), {
+    initializeGrabScroll: S,
+    scrollBehavior: L,
+    resetGrabState: E
+  };
+};
+export {
+  b as useGrabScroll
+};

package/dist/utils/hooks/useHighlight.js

@@ -0,0 +1,54 @@
+import { useState as l, useCallback as x, useEffect as C } from "react";
+import { getHighlightOptionsWithDefaults as H, findMatches as M } from "../highlight.js";
+const d = (i) => {
+  const [n, a] = l(void 0), [u, r] = l([]), f = x(async (t) => {
+    if (!t)
+      return {};
+    const s = t.numPages, e = {};
+    for (let o = 1; o <= s; o++) {
+      const g = await t.getPage(o);
+      e[o.toString()] = await g.getTextContent();
+    }
+    return e;
+  }, []), m = async (t) => {
+    a(t);
+  }, c = () => {
+    r([]), a(void 0);
+  };
+  return C(() => {
+    i && f(i).then((t) => {
+      let s = [];
+      for (const { keyword: e, highlightColor: o, options: g } of n) {
+        if (!e)
+          continue;
+        const p = H(g);
+        for (const h of Object.keys(t)) {
+          const y = M(
+            [e],
+            t[h],
+            Number(h) - 1,
+            p
+          ).map((b, w) => ({
+            ...b,
+            page: Number(h),
+            pageMatchIdx: w,
+            color: o,
+            keyword: e
+          }));
+          s = [...s, ...y];
+        }
+      }
+      r(s);
+    }).catch(() => {
+      c();
+    });
+  }, [n, i]), {
+    highlight: m,
+    clear: c,
+    highlightMatches: u,
+    highlightKeywords: n
+  };
+};
+export {
+  d as useHighlight
+};

package/dist/utils/hooks/useInfiniteScroll.js

@@ -0,0 +1,19 @@
+import { useCallback as l, useEffect as f } from "react";
+const v = (s, c, h = {}) => {
+  const { distance: i = 10, loadFirst: t = !1 } = h, o = l(
+    (u) => {
+      if (!s)
+        return;
+      s.scrollHeight - s.clientHeight - s.scrollTop < i && c();
+    },
+    [c, s, i]
+  );
+  f(() => {
+    t && c();
+  }, [t]), f(() => (s == null || s.addEventListener("scroll", o), () => {
+    s == null || s.removeEventListener("scroll", o);
+  }), [o, s]);
+};
+export {
+  v as useInfiniteScroll
+};

package/dist/utils/hooks/useLicense.js

@@ -0,0 +1,110 @@
+import { useState as E, useCallback as h, useEffect as A } from "react";
+import { appConsole as l } from "../appConsole.js";
+const b = /* @__PURE__ */ new Date("2026-01-05T03:59:23.044Z"), d = "Please visit https://www.react-pdf.dev/manage-license/ to generate a new license key.", s = {
+  invalidLicense: `You are currently using without a valid license. ${d}`,
+  mismatchedDomain: `Your license key is not valid for the current domain / IP. ${d}`,
+  expired: `Your license key has expired. ${d}`,
+  exceededVersion: "Your license does not support the current version of React PDF. The library version you are using exceeds the supported range of your license.",
+  invalidSignature: "Invalid license key: Signature mismatch"
+};
+function L(r) {
+  const t = r.replace(/-----BEGIN PUBLIC KEY-----/, "").replace(/-----END PUBLIC KEY-----/, "").replace(/\s+/g, ""), e = atob(t), n = new Uint8Array(e.length);
+  for (let i = 0; i < e.length; i++)
+    n[i] = e.charCodeAt(i);
+  return n.buffer;
+}
+function S(r) {
+  const t = atob(r), e = new Uint8Array(t.length);
+  for (let n = 0; n < t.length; n++)
+    e[n] = t.charCodeAt(n);
+  return e.buffer;
+}
+async function I(r, t = "SHA-256") {
+  try {
+    const { data: e, signature: n } = JSON.parse(atob(r)), i = L(`-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvIokvErJ0Fctu0jduSAx
+gr+5Har/VSuZLlOunS28hnlqqA+OF1apHL7RYkjBosS15yvviYdLrVWYHpHnoY4b
+HLQ9I6YX6FMB9T/VbB4xLdVdKvfi8r49aTScl5EKuSpgpPgz2VSJTfvVGcRuth/Y
+Bm7PPGYdL2l2gvKDxchmmsHFPukGki9L4JOUeIVX0GXAxabENckaEH/iC1NZhX+W
+vXnpHeHuIIKlZ16LSivXNgo6BH2Z3GFdg4G3cAaXr6qNP8fsacYNqv2SpTW1viFD
+vzcGRabN25gpJAp9/syeScefWH3OiJY1lmw88oTiJbjIoiq6AkPhfn3G9mF54nvR
+kwIDAQAB
+-----END PUBLIC KEY-----`), a = await window.crypto.subtle.importKey(
+      "spki",
+      // str2ab(publicKeyContent), // Convert PEM string to ArrayBuffer
+      i,
+      { name: "RSA-PSS", hash: t },
+      !0,
+      ["verify"]
+    );
+    if (!await window.crypto.subtle.verify(
+      { name: "RSA-PSS", saltLength: 32 },
+      a,
+      S(n),
+      // Convert signature to ArrayBuffer
+      new TextEncoder().encode(atob(e))
+    ))
+      throw new Error(s.invalidSignature);
+    return JSON.parse(atob(e));
+  } catch {
+    throw new Error(s.invalidLicense);
+  }
+}
+const y = (r, t) => r === "specific" ? t === window.location.host : window.location.host.includes(t), u = {
+  isValid: !0,
+  invalidatedMessage: s.invalidLicense,
+  type: void 0
+}, x = (r) => {
+  const [t, e] = E(u), n = h(async () => {
+    if (e((c) => ({ ...c, validating: !0 })), !r)
+      throw e({ ...u, validating: !1 }), new Error(s.invalidLicense);
+    let i;
+    try {
+      i = await I(r);
+    } catch (c) {
+      throw l.warn(c.message), new Error(c.message);
+    }
+    l.debug(">>> validatedLicense", i);
+    const { avu: a, exp: o, dmt: m, dm: w, t: f } = i;
+    if (!o)
+      throw new Error("License is missing expiration timestamp");
+    if (o > Number.MAX_SAFE_INTEGER / 1e3)
+      throw new Error("Invalid expiration timestamp: value too large");
+    const p = new Date(o * 1e3), g = (/* @__PURE__ */ new Date()).getTime();
+    if (p.getTime() < g)
+      throw new Error(s.expired);
+    if (!a)
+      throw new Error("License is missing available until version timestamp");
+    if (a > Number.MAX_SAFE_INTEGER / 1e3)
+      throw new Error("Invalid available until version timestamp: value too large");
+    const v = new Date(a * 1e3);
+    if (l.debug("availableUntilTimestamp", v), v.getTime() < b.getTime())
+      throw new Error(s.exceededVersion);
+    if (!y(m, w))
+      throw new Error(s.mismatchedDomain);
+    return {
+      isValid: !0,
+      type: f,
+      invalidatedMessage: void 0
+    };
+  }, [r]);
+  return A(() => {
+    n().then(({ isValid: i, type: a, invalidatedMessage: o }) => {
+      e({
+        isValid: i,
+        type: a,
+        invalidatedMessage: o,
+        validating: !1
+      });
+    }).catch((i) => {
+      e({
+        ...u,
+        isValid: !1,
+        validating: !1
+      }), l.warn(i.message);
+    });
+  }, [n]), t;
+};
+export {
+  x as useLicense
+};