@pdf-viewer/react 0.0.0-experimental.6 → 0.0.0-experimental.7

package/dist/utils/hooks/useLicense.js

@@ -1,27 +1,1124 @@
-import { useState as E, useCallback as h, useEffect as A } from "react";
-import { appConsole as l } from "../appConsole.js";
-const b = /* @__PURE__ */ new Date("2025-12-18T09:25:21.359Z"), 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}`,
+import { b as $, s as Q, g as D, m as Ke, N as gt, r as F, H as G, O as Et, i as Ze, J as Nr, K as Tt, G as _t, j as Rt, q as mt, F as bt, k as It, P as qt, L as wt, l as rt, p as Ot, a as St, Q as Bt, t as Ct, w as xt, I as Dt, x as Nt, e as Pt } from "../../is-pure-db2321f6.js";
+import { r as Pr } from "../../function-uncurry-this-accessor-efc140e6.js";
+import { b as Ur, c as Ut, a as Lr, r as J } from "../../classof-56f81803.js";
+import "../../esnext.json.parse-3bf99e2e.js";
+import { useState as Lt, useCallback as Mt, useEffect as Ft } from "react";
+import { appConsole as z } from "../appConsole.js";
+var Hr = {}, rr, jr;
+function Vt() {
+  if (jr)
+    return rr;
+  jr = 1;
+  var r = Ur(), t = Ut(), e = RangeError;
+  return rr = function(a) {
+    if (a === void 0)
+      return 0;
+    var n = r(a), i = t(n);
+    if (n !== i)
+      throw new e("Wrong length or index");
+    return i;
+  }, rr;
+}
+var kr = {}, Gr;
+function $t() {
+  if (Gr)
+    return kr;
+  Gr = 1;
+  var r = $(), t = nt();
+  return t && r({
+    target: "ArrayBuffer",
+    proto: !0
+  }, {
+    transferToFixedLength: function() {
+      return t(this, arguments.length ? arguments[0] : void 0, !1);
+    }
+  }), kr;
+}
+$t();
+module.exports = typeof ArrayBuffer < "u" && typeof DataView < "u";
+const Ht = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" })), et = /* @__PURE__ */ Q(Ht);
+var er, Yr;
+function tt() {
+  if (Yr)
+    return er;
+  Yr = 1;
+  var r = D(), t = Pr(), e = Ke(), a = r.ArrayBuffer, n = r.TypeError;
+  return er = a && t(a.prototype, "byteLength", "get") || function(i) {
+    if (e(i) !== "ArrayBuffer")
+      throw new n("ArrayBuffer expected");
+    return i.byteLength;
+  }, er;
+}
+var tr, Wr;
+function jt() {
+  if (Wr)
+    return tr;
+  Wr = 1;
+  var r = D(), t = et, e = tt(), a = r.DataView;
+  return tr = function(n) {
+    if (!t || e(n) !== 0)
+      return !1;
+    try {
+      return new a(n), !1;
+    } catch {
+      return !0;
+    }
+  }, tr;
+}
+var ar, Xr;
+function Y() {
+  if (Xr)
+    return ar;
+  Xr = 1;
+  var r = jt(), t = TypeError;
+  return ar = function(e) {
+    if (r(e))
+      throw new t("ArrayBuffer is detached");
+    return e;
+  }, ar;
+}
+var nr, zr;
+function kt() {
+  if (zr)
+    return nr;
+  zr = 1;
+  var r = D(), t = gt(), e = Ke(), a = function(n) {
+    return t.slice(0, n.length) === n;
+  };
+  return nr = function() {
+    return a("Bun/") ? "BUN" : a("Cloudflare-Workers") ? "CLOUDFLARE" : a("Deno/") ? "DENO" : a("Node.js/") ? "NODE" : r.Bun && typeof Bun.version == "string" ? "BUN" : r.Deno && typeof Deno.version == "object" ? "DENO" : e(r.process) === "process" ? "NODE" : r.window && r.document ? "BROWSER" : "REST";
+  }(), nr;
+}
+var ir, Qr;
+function Gt() {
+  if (Qr)
+    return ir;
+  Qr = 1;
+  var r = kt();
+  return ir = r === "NODE", ir;
+}
+var or, Jr;
+function Yt() {
+  if (Jr)
+    return or;
+  Jr = 1;
+  var r = D(), t = Gt();
+  return or = function(e) {
+    if (t) {
+      try {
+        return r.process.getBuiltinModule(e);
+      } catch {
+      }
+      try {
+        return Function('return require("' + e + '")')();
+      } catch {
+      }
+    }
+  }, or;
+}
+var Wt = require("../internals/global-this"), Xt = require("../internals/fails"), ur = require("../internals/environment-v8-version"), sr = require("../internals/environment"), Kr = Wt.structuredClone;
+module.exports = !!Kr && !Xt(function() {
+  if (sr === "DENO" && ur > 92 || sr === "NODE" && ur > 94 || sr === "BROWSER" && ur > 97)
+    return !1;
+  var r = new ArrayBuffer(8), t = Kr(r, {
+    transfer: [r]
+  });
+  return r.byteLength !== 0 || t.byteLength !== 8;
+});
+const zt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" })), at = /* @__PURE__ */ Q(zt);
+var fr, Zr;
+function Qt() {
+  if (Zr)
+    return fr;
+  Zr = 1;
+  var r = D(), t = Yt(), e = at, a = r.structuredClone, n = r.ArrayBuffer, i = r.MessageChannel, o = !1, s, c, f, v;
+  if (e)
+    o = function(l) {
+      a(l, {
+        transfer: [l]
+      });
+    };
+  else if (n)
+    try {
+      i || (s = t("worker_threads"), s && (i = s.MessageChannel)), i && (c = new i(), f = new n(2), v = function(l) {
+        c.port1.postMessage(null, [l]);
+      }, f.byteLength === 2 && (v(f), f.byteLength === 0 && (o = v)));
+    } catch {
+    }
+  return fr = o, fr;
+}
+var vr, re;
+function nt() {
+  if (re)
+    return vr;
+  re = 1;
+  var r = D(), t = F(), e = Pr(), a = Vt(), n = Y(), i = tt(), o = Qt(), s = at, c = r.structuredClone, f = r.ArrayBuffer, v = r.DataView, l = Math.min, d = f.prototype, m = v.prototype, g = t(d.slice), w = e(d, "resizable", "get"), y = e(d, "maxByteLength", "get"), E = t(m.getInt8), b = t(m.setInt8);
+  return vr = (s || o) && function(u, p, A) {
+    var _ = i(u), h = p === void 0 ? _ : a(p), T = !w || !w(u), O;
+    if (n(u), s && (u = c(u, {
+      transfer: [u]
+    }), _ === h && (A || T)))
+      return u;
+    if (_ >= h && (!A || T))
+      O = g(u, 0, h);
+    else {
+      var I = A && !T && y ? {
+        maxByteLength: y(u)
+      } : void 0;
+      O = new f(h, I);
+      for (var q = new v(u), U = new v(O), N = l(h, _), B = 0; B < N; B++)
+        b(U, B, E(q, B));
+    }
+    return s || o(u), O;
+  }, vr;
+}
+var ee;
+function Jt() {
+  if (ee)
+    return Hr;
+  ee = 1;
+  var r = $(), t = nt();
+  return t && r({
+    target: "ArrayBuffer",
+    proto: !0
+  }, {
+    transfer: function() {
+      return t(this, arguments.length ? arguments[0] : void 0, !0);
+    }
+  }), Hr;
+}
+Jt();
+var Kt = require("../internals/descriptors"), Zt = require("../internals/define-built-in-accessor"), ra = require("../internals/array-buffer-is-detached"), te = ArrayBuffer.prototype;
+Kt && !("detached" in te) && Zt(te, "detached", {
+  configurable: !0,
+  get: function() {
+    return ra(this);
+  }
+});
+var ae = {}, cr, ne;
+function ea() {
+  if (ne)
+    return cr;
+  ne = 1;
+  var r = Lr();
+  return cr = function(t, e) {
+    for (var a = r(t), n = new e(a), i = 0; i < a; i++)
+      n[i] = t[a - i - 1];
+    return n;
+  }, cr;
+}
+var yr, ie;
+function ta() {
+  if (ie)
+    return yr;
+  ie = 1;
+  var r = G();
+  return yr = function(t) {
+    return r(t) || t === null;
+  }, yr;
+}
+var dr, oe;
+function aa() {
+  if (oe)
+    return dr;
+  oe = 1;
+  var r = ta(), t = String, e = TypeError;
+  return dr = function(a) {
+    if (r(a))
+      return a;
+    throw new e("Can't set " + t(a) + " as a prototype");
+  }, dr;
+}
+var lr, ue;
+function it() {
+  if (ue)
+    return lr;
+  ue = 1;
+  var r = Pr(), t = G(), e = Et(), a = aa();
+  return lr = Object.setPrototypeOf || ("__proto__" in {} ? function() {
+    var n = !1, i = {}, o;
+    try {
+      o = r(Object.prototype, "__proto__", "set"), o(i, []), n = i instanceof Array;
+    } catch {
+    }
+    return function(c, f) {
+      return e(c), a(f), t(c) && (n ? o(c, f) : c.__proto__ = f), c;
+    };
+  }() : void 0), lr;
+}
+var pr, se;
+function W() {
+  if (se)
+    return pr;
+  se = 1;
+  var r = et, t = Ze(), e = D(), a = rt(), n = G(), i = Nr(), o = J(), s = Ot(), c = Tt(), f = _t(), v = Rt(), l = mt(), d = bt(), m = it(), g = It(), w = qt(), y = wt(), E = y.enforce, b = y.get, u = e.Int8Array, p = u && u.prototype, A = e.Uint8ClampedArray, _ = A && A.prototype, h = u && d(u), T = p && d(p), O = Object.prototype, I = e.TypeError, q = g("toStringTag"), U = w("TYPED_ARRAY_TAG"), N = "TypedArrayConstructor", B = r && !!m && o(e.opera) !== "Opera", X = !1, S, P, H, M = {
+    Int8Array: 1,
+    Uint8Array: 1,
+    Uint8ClampedArray: 1,
+    Int16Array: 2,
+    Uint16Array: 2,
+    Int32Array: 4,
+    Uint32Array: 4,
+    Float32Array: 4,
+    Float64Array: 8
+  }, Z = {
+    BigInt64Array: 8,
+    BigUint64Array: 8
+  }, dt = function(C) {
+    if (!n(C))
+      return !1;
+    var x = o(C);
+    return x === "DataView" || i(M, x) || i(Z, x);
+  }, Vr = function(R) {
+    var C = d(R);
+    if (n(C)) {
+      var x = b(C);
+      return x && i(x, N) ? x[N] : Vr(C);
+    }
+  }, $r = function(R) {
+    if (!n(R))
+      return !1;
+    var C = o(R);
+    return i(M, C) || i(Z, C);
+  }, lt = function(R) {
+    if ($r(R))
+      return R;
+    throw new I("Target is not a typed array");
+  }, pt = function(R) {
+    if (a(R) && (!m || l(h, R)))
+      return R;
+    throw new I(s(R) + " is not a typed array constructor");
+  }, At = function(R, C, x, j) {
+    if (t) {
+      if (x)
+        for (var L in M) {
+          var k = e[L];
+          if (k && i(k.prototype, R))
+            try {
+              delete k.prototype[R];
+            } catch {
+              try {
+                k.prototype[R] = C;
+              } catch {
+              }
+            }
+        }
+      (!T[R] || x) && f(T, R, x ? C : B && p[R] || C, j);
+    }
+  }, ht = function(R, C, x) {
+    var j, L;
+    if (t) {
+      if (m) {
+        if (x) {
+          for (j in M)
+            if (L = e[j], L && i(L, R))
+              try {
+                delete L[R];
+              } catch {
+              }
+        }
+        if (!h[R] || x)
+          try {
+            return f(h, R, x ? C : B && h[R] || C);
+          } catch {
+          }
+        else
+          return;
+      }
+      for (j in M)
+        L = e[j], L && (!L[R] || x) && f(L, R, C);
+    }
+  };
+  for (S in M)
+    P = e[S], H = P && P.prototype, H ? E(H)[N] = P : B = !1;
+  for (S in Z)
+    P = e[S], H = P && P.prototype, H && (E(H)[N] = P);
+  if ((!B || !a(h) || h === Function.prototype) && (h = function() {
+    throw new I("Incorrect invocation");
+  }, B))
+    for (S in M)
+      e[S] && m(e[S], h);
+  if ((!B || !T || T === O) && (T = h.prototype, B))
+    for (S in M)
+      e[S] && m(e[S].prototype, T);
+  if (B && d(_) !== T && m(_, T), t && !i(T, q)) {
+    X = !0, v(T, q, {
+      configurable: !0,
+      get: function() {
+        return n(this) ? this[U] : void 0;
+      }
+    });
+    for (S in M)
+      e[S] && c(e[S], U, S);
+  }
+  return pr = {
+    NATIVE_ARRAY_BUFFER_VIEWS: B,
+    TYPED_ARRAY_TAG: X && U,
+    aTypedArray: lt,
+    aTypedArrayConstructor: pt,
+    exportTypedArrayMethod: At,
+    exportTypedArrayStaticMethod: ht,
+    getTypedArrayConstructor: Vr,
+    isView: dt,
+    isTypedArray: $r,
+    TypedArray: h,
+    TypedArrayPrototype: T
+  }, pr;
+}
+var fe;
+function na() {
+  if (fe)
+    return ae;
+  fe = 1;
+  var r = ea(), t = W(), e = t.aTypedArray, a = t.exportTypedArrayMethod, n = t.getTypedArrayConstructor;
+  return a("toReversed", function() {
+    return r(e(this), n(this));
+  }), ae;
+}
+na();
+var ve = {}, Ar, ce;
+function ot() {
+  if (ce)
+    return Ar;
+  ce = 1;
+  var r = Lr();
+  return Ar = function(t, e, a) {
+    for (var n = 0, i = arguments.length > 2 ? a : r(e), o = new t(i); i > n; )
+      o[n] = e[n++];
+    return o;
+  }, Ar;
+}
+var ye;
+function ia() {
+  if (ye)
+    return ve;
+  ye = 1;
+  var r = W(), t = F(), e = St(), a = ot(), n = r.aTypedArray, i = r.getTypedArrayConstructor, o = r.exportTypedArrayMethod, s = t(r.TypedArrayPrototype.sort);
+  return o("toSorted", function(f) {
+    f !== void 0 && e(f);
+    var v = n(this), l = a(i(v), v);
+    return s(l, f);
+  }), ve;
+}
+ia();
+var oa = require("../internals/export"), ua = require("../internals/array-with"), sa = require("../internals/to-indexed-object"), fa = Array, va = function() {
+  try {
+    [].with({
+      valueOf: function() {
+        throw 4;
+      }
+    }, null);
+  } catch (r) {
+    return r !== 4;
+  }
+}();
+oa({
+  target: "Array",
+  proto: !0,
+  forced: va
+}, {
+  with: function(r, t) {
+    return ua(sa(this), fa, r, t);
+  }
+});
+var ca = require("../internals/export"), ya = require("../internals/array-iteration").filterReject, da = require("../internals/add-to-unscopables");
+ca({
+  target: "Array",
+  proto: !0,
+  forced: !0
+}, {
+  filterReject: function(t) {
+    return ya(this, t, arguments.length > 1 ? arguments[1] : void 0);
+  }
+});
+da("filterReject");
+var ut = require("../internals/array-buffer-view-core"), la = require("../internals/array-iteration").filterReject, pa = require("../internals/typed-array-from-same-type-and-list"), Aa = ut.aTypedArray, ha = ut.exportTypedArrayMethod;
+ha("filterReject", function(t) {
+  var e = la(Aa(this), t, arguments.length > 1 ? arguments[1] : void 0);
+  return pa(this, e);
+}, !0);
+var de = {}, ga = require("../internals/function-bind-context"), Ea = require("../internals/function-uncurry-this"), Ta = require("../internals/indexed-object"), _a = require("../internals/to-object"), Ra = require("../internals/to-property-key"), ma = require("../internals/length-of-array-like"), ba = require("../internals/object-create"), Ia = require("../internals/array-from-constructor-and-list"), qa = Array, wa = Ea([].push);
+module.exports = function(r, t, e, a) {
+  for (var n = _a(r), i = Ta(n), o = ga(t, e), s = ba(null), c = ma(i), f = 0, v, l, d; c > f; f++)
+    d = i[f], l = Ra(o(d, f, n)), l in s ? wa(s[l], d) : s[l] = [d];
+  if (a && (v = a(n), v !== qa))
+    for (l in s)
+      s[l] = Ia(v, s[l]);
+  return s;
+};
+const Oa = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" })), Sa = /* @__PURE__ */ Q(Oa);
+var le;
+function Ba() {
+  if (le)
+    return de;
+  le = 1;
+  var r = W(), t = Sa, e = r.aTypedArray, a = r.getTypedArrayConstructor, n = r.exportTypedArrayMethod;
+  return n("groupBy", function(o) {
+    var s = arguments.length > 1 ? arguments[1] : void 0;
+    return t(e(this), o, s, a);
+  }, !0), de;
+}
+Ba();
+var pe = {}, hr, Ae;
+function Ca() {
+  if (Ae)
+    return hr;
+  Ae = 1;
+  var r = J();
+  return hr = function(t) {
+    var e = r(t);
+    return e === "BigInt64Array" || e === "BigUint64Array";
+  }, hr;
+}
+var gr, he;
+function xa() {
+  if (he)
+    return gr;
+  he = 1;
+  var r = Ur(), t = Math.max, e = Math.min;
+  return gr = function(a, n) {
+    var i = r(a);
+    return i < 0 ? t(i + n, 0) : e(i, n);
+  }, gr;
+}
+var Er, ge;
+function Da() {
+  if (ge)
+    return Er;
+  ge = 1;
+  var r = Bt(), t = TypeError;
+  return Er = function(e) {
+    var a = r(e, "number");
+    if (typeof a == "number")
+      throw new t("Can't convert number to bigint");
+    return BigInt(a);
+  }, Er;
+}
+var Ee;
+function Na() {
+  if (Ee)
+    return pe;
+  Ee = 1;
+  var r = W(), t = Lr(), e = Ca(), a = xa(), n = Da(), i = Ur(), o = r.aTypedArray, s = r.getTypedArrayConstructor, c = r.exportTypedArrayMethod, f = Math.max, v = Math.min;
+  return c("toSpliced", function(d, m) {
+    var g = o(this), w = s(g), y = t(g), E = a(d, y), b = arguments.length, u = 0, p, A, _, h, T, O, I;
+    if (b === 0)
+      p = A = 0;
+    else if (b === 1)
+      p = 0, A = y - E;
+    else if (A = v(f(i(m), 0), y - E), p = b - 2, p) {
+      h = new w(p), _ = e(h);
+      for (var q = 2; q < b; q++)
+        T = arguments[q], h[q - 2] = _ ? n(T) : +T;
+    }
+    for (O = y + p - A, I = new w(O); u < E; u++)
+      I[u] = g[u];
+    for (; u < E + p; u++)
+      I[u] = h[u - E];
+    for (; u < O; u++)
+      I[u] = g[u + A - p];
+    return I;
+  }, !0), pe;
+}
+Na();
+var Te = {}, Pa = require("../internals/function-uncurry-this"), Ua = require("../internals/a-callable"), La = require("../internals/is-null-or-undefined"), Ma = require("../internals/length-of-array-like"), Fa = require("../internals/to-object"), Mr = require("../internals/map-helpers"), Va = require("../internals/map-iterate"), $a = Mr.Map, Ha = Mr.has, ja = Mr.set, ka = Pa([].push);
+module.exports = function(t) {
+  var e = Fa(this), a = Ma(e), n = [], i = new $a(), o = La(t) ? function(v) {
+    return v;
+  } : Ua(t), s, c, f;
+  for (s = 0; s < a; s++)
+    c = e[s], f = o(c), Ha(i, f) || ja(i, f, c);
+  return Va(i, function(v) {
+    ka(n, v);
+  }), n;
+};
+const Ga = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" })), Ya = /* @__PURE__ */ Q(Ga);
+var _e;
+function Wa() {
+  if (_e)
+    return Te;
+  _e = 1;
+  var r = F(), t = W(), e = ot(), a = Ya, n = t.aTypedArray, i = t.getTypedArrayConstructor, o = t.exportTypedArrayMethod, s = r(a);
+  return o("uniqueBy", function(f) {
+    return n(this), e(i(this), s(this, f));
+  }, !0), Te;
+}
+Wa();
+var Xa = require("../internals/array-with"), Fr = require("../internals/array-buffer-view-core"), za = require("../internals/is-big-int-array"), Qa = require("../internals/to-integer-or-infinity"), Ja = require("../internals/to-big-int"), Ka = Fr.aTypedArray, Za = Fr.getTypedArrayConstructor, rn = Fr.exportTypedArrayMethod, st = function() {
+  try {
+    new Int8Array(1).with(2, {
+      valueOf: function() {
+        throw 8;
+      }
+    });
+  } catch (r) {
+    return r === 8;
+  }
+}(), en = st && function() {
+  try {
+    new Int8Array(1).with(-0.5, 1);
+  } catch {
+    return !0;
+  }
+}();
+rn("with", function(r, t) {
+  var e = Ka(this), a = Qa(r), n = za(e) ? Ja(t) : +t;
+  return Xa(e, Za(e), a, n);
+}, !st || en);
+var Re = {}, me = {}, Tr, be;
+function ft() {
+  if (be)
+    return Tr;
+  be = 1;
+  var r = G(), t = String, e = TypeError;
+  return Tr = function(a) {
+    if (a === void 0 || r(a))
+      return a;
+    throw new e(t(a) + " is not an object or undefined");
+  }, Tr;
+}
+var _r, Ie;
+function vt() {
+  if (Ie)
+    return _r;
+  Ie = 1;
+  var r = TypeError;
+  return _r = function(t) {
+    if (typeof t == "string")
+      return t;
+    throw new r("Argument is not a string");
+  }, _r;
+}
+var Rr, qe;
+function ct() {
+  if (qe)
+    return Rr;
+  qe = 1;
+  var r = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", t = r + "+/", e = r + "-_", a = function(n) {
+    for (var i = {}, o = 0; o < 64; o++)
+      i[n.charAt(o)] = o;
+    return i;
+  };
+  return Rr = {
+    i2c: t,
+    c2i: a(t),
+    i2cUrl: e,
+    c2iUrl: a(e)
+  }, Rr;
+}
+var mr, we;
+function yt() {
+  if (we)
+    return mr;
+  we = 1;
+  var r = TypeError;
+  return mr = function(t) {
+    var e = t && t.alphabet;
+    if (e === void 0 || e === "base64" || e === "base64url")
+      return e || "base64";
+    throw new r("Incorrect `alphabet` option");
+  }, mr;
+}
+var br, Oe;
+function tn() {
+  if (Oe)
+    return br;
+  Oe = 1;
+  var r = D(), t = F(), e = ft(), a = vt(), n = Nr(), i = ct(), o = yt(), s = Y(), c = i.c2i, f = i.c2iUrl, v = r.SyntaxError, l = r.TypeError, d = t("".charAt), m = function(y, E) {
+    for (var b = y.length; E < b; E++) {
+      var u = d(y, E);
+      if (u !== " " && u !== "	" && u !== `
+` && u !== "\f" && u !== "\r")
+        break;
+    }
+    return E;
+  }, g = function(y, E, b) {
+    var u = y.length;
+    u < 4 && (y += u === 2 ? "AA" : "A");
+    var p = (E[d(y, 0)] << 18) + (E[d(y, 1)] << 12) + (E[d(y, 2)] << 6) + E[d(y, 3)], A = [p >> 16 & 255, p >> 8 & 255, p & 255];
+    if (u === 2) {
+      if (b && A[1] !== 0)
+        throw new v("Extra bits");
+      return [A[0]];
+    }
+    if (u === 3) {
+      if (b && A[2] !== 0)
+        throw new v("Extra bits");
+      return [A[0], A[1]];
+    }
+    return A;
+  }, w = function(y, E, b) {
+    for (var u = E.length, p = 0; p < u; p++)
+      y[b + p] = E[p];
+    return b + u;
+  };
+  return br = function(y, E, b, u) {
+    a(y), e(E);
+    var p = o(E) === "base64" ? c : f, A = E ? E.lastChunkHandling : void 0;
+    if (A === void 0 && (A = "loose"), A !== "loose" && A !== "strict" && A !== "stop-before-partial")
+      throw new l("Incorrect `lastChunkHandling` option");
+    b && s(b.buffer);
+    var _ = y.length, h = b || [], T = 0, O = 0, I = "", q = 0;
+    if (u)
+      for (; ; ) {
+        if (q = m(y, q), q === _) {
+          if (I.length > 0) {
+            if (A === "stop-before-partial")
+              break;
+            if (A === "loose") {
+              if (I.length === 1)
+                throw new v("Malformed padding: exactly one additional character");
+              T = w(h, g(I, p, !1), T);
+            } else
+              throw new v("Missing padding");
+          }
+          O = _;
+          break;
+        }
+        var U = d(y, q);
+        if (++q, U === "=") {
+          if (I.length < 2)
+            throw new v("Padding is too early");
+          if (q = m(y, q), I.length === 2) {
+            if (q === _) {
+              if (A === "stop-before-partial")
+                break;
+              throw new v("Malformed padding: only one =");
+            }
+            d(y, q) === "=" && (++q, q = m(y, q));
+          }
+          if (q < _)
+            throw new v("Unexpected character after padding");
+          T = w(h, g(I, p, A === "strict"), T), O = _;
+          break;
+        }
+        if (!n(p, U))
+          throw new v("Unexpected character");
+        var N = u - T;
+        if (N === 1 && I.length === 2 || N === 2 && I.length === 3 || (I += U, I.length === 4 && (T = w(h, g(I, p, !1), T), I = "", O = q, T === u)))
+          break;
+      }
+    return {
+      bytes: h,
+      read: O,
+      written: T
+    };
+  }, br;
+}
+var Ir, Se;
+function K() {
+  if (Se)
+    return Ir;
+  Se = 1;
+  var r = J(), t = TypeError;
+  return Ir = function(e) {
+    if (r(e) === "Uint8Array")
+      return e;
+    throw new t("Argument is not an Uint8Array");
+  }, Ir;
+}
+var Be;
+function an() {
+  if (Be)
+    return me;
+  Be = 1;
+  var r = $(), t = D(), e = tn(), a = K(), n = t.Uint8Array, i = !n || !n.prototype.setFromBase64 || !function() {
+    var o = new n([255, 255, 255, 255, 255]);
+    try {
+      o.setFromBase64("", null);
+      return;
+    } catch {
+    }
+    try {
+      o.setFromBase64("a");
+      return;
+    } catch {
+    }
+    try {
+      o.setFromBase64("MjYyZg===");
+    } catch {
+      return o[0] === 50 && o[1] === 54 && o[2] === 50 && o[3] === 255 && o[4] === 255;
+    }
+  }();
+  return n && r({
+    target: "Uint8Array",
+    proto: !0,
+    forced: i
+  }, {
+    setFromBase64: function(s) {
+      a(this);
+      var c = e(s, arguments.length > 1 ? arguments[1] : void 0, this, this.length);
+      return {
+        read: c.read,
+        written: c.written
+      };
+    }
+  }), me;
+}
+var Ce;
+function nn() {
+  return Ce || (Ce = 1, an()), Re;
+}
+nn();
+var xe = {}, De = {}, qr, Ne;
+function on() {
+  if (Ne)
+    return qr;
+  Ne = 1;
+  var r = D(), t = F(), e = r.Uint8Array, a = r.SyntaxError, n = r.parseInt, i = Math.min, o = /[^\da-f]/i, s = t(o.exec), c = t("".slice);
+  return qr = function(f, v) {
+    var l = f.length;
+    if (l % 2 !== 0)
+      throw new a("String should be an even number of characters");
+    for (var d = v ? i(v.length, l / 2) : l / 2, m = v || new e(d), g = 0, w = 0; w < d; ) {
+      var y = c(f, g, g += 2);
+      if (s(o, y))
+        throw new a("String should only contain hex characters");
+      m[w++] = n(y, 16);
+    }
+    return {
+      bytes: m,
+      read: g
+    };
+  }, qr;
+}
+var Pe;
+function un() {
+  if (Pe)
+    return De;
+  Pe = 1;
+  var r = $(), t = D(), e = vt(), a = K(), n = Y(), i = on();
+  return t.Uint8Array && r({
+    target: "Uint8Array",
+    proto: !0
+  }, {
+    setFromHex: function(s) {
+      a(this), e(s), n(this.buffer);
+      var c = i(s, this).read;
+      return {
+        read: c,
+        written: c / 2
+      };
+    }
+  }), De;
+}
+var Ue;
+function sn() {
+  return Ue || (Ue = 1, un()), xe;
+}
+sn();
+var Le = {}, Me = {}, Fe;
+function fn() {
+  if (Fe)
+    return Me;
+  Fe = 1;
+  var r = $(), t = D(), e = F(), a = ft(), n = K(), i = Y(), o = ct(), s = yt(), c = o.i2c, f = o.i2cUrl, v = e("".charAt), l = t.Uint8Array, d = !l || !l.prototype.toBase64 || !function() {
+    try {
+      var m = new l();
+      m.toBase64(null);
+    } catch {
+      return !0;
+    }
+  }();
+  return l && r({
+    target: "Uint8Array",
+    proto: !0,
+    forced: d
+  }, {
+    toBase64: function() {
+      var g = n(this), w = arguments.length ? a(arguments[0]) : void 0, y = s(w) === "base64" ? c : f, E = !!w && !!w.omitPadding;
+      i(this.buffer);
+      for (var b = "", u = 0, p = g.length, A, _ = function(h) {
+        return v(y, A >> 6 * h & 63);
+      }; u + 2 < p; u += 3)
+        A = (g[u] << 16) + (g[u + 1] << 8) + g[u + 2], b += _(3) + _(2) + _(1) + _(0);
+      return u + 2 === p ? (A = (g[u] << 16) + (g[u + 1] << 8), b += _(3) + _(2) + _(1) + (E ? "" : "=")) : u + 1 === p && (A = g[u] << 16, b += _(3) + _(2) + (E ? "" : "==")), b;
+    }
+  }), Me;
+}
+var Ve;
+function vn() {
+  return Ve || (Ve = 1, fn()), Le;
+}
+vn();
+var $e = {}, He = {}, je;
+function cn() {
+  if (je)
+    return He;
+  je = 1;
+  var r = $(), t = D(), e = F(), a = K(), n = Y(), i = e(1.1.toString), o = t.Uint8Array, s = !o || !o.prototype.toHex || !function() {
+    try {
+      var c = new o([255, 255, 255, 255, 255, 255, 255, 255]);
+      return c.toHex() === "ffffffffffffffff";
+    } catch {
+      return !1;
+    }
+  }();
+  return o && r({
+    target: "Uint8Array",
+    proto: !0,
+    forced: s
+  }, {
+    toHex: function() {
+      a(this), n(this.buffer);
+      for (var f = "", v = 0, l = this.length; v < l; v++) {
+        var d = i(this[v], 16);
+        f += d.length === 1 ? "0" + d : d;
+      }
+      return f;
+    }
+  }), He;
+}
+var ke;
+function yn() {
+  return ke || (ke = 1, cn()), $e;
+}
+yn();
+var Ge = {}, wr, Ye;
+function dn() {
+  if (Ye)
+    return wr;
+  Ye = 1;
+  var r = rt(), t = G(), e = it();
+  return wr = function(a, n, i) {
+    var o, s;
+    return (
+      // it can work only with native `setPrototypeOf`
+      e && // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
+      r(o = n.constructor) && o !== i && t(s = o.prototype) && s !== i.prototype && e(a, s), a
+    );
+  }, wr;
+}
+var Or, We;
+function ln() {
+  if (We)
+    return Or;
+  We = 1;
+  var r = J(), t = String;
+  return Or = function(e) {
+    if (r(e) === "Symbol")
+      throw new TypeError("Cannot convert a Symbol value to a string");
+    return t(e);
+  }, Or;
+}
+var Sr, Xe;
+function pn() {
+  if (Xe)
+    return Sr;
+  Xe = 1;
+  var r = ln();
+  return Sr = function(t, e) {
+    return t === void 0 ? arguments.length < 2 ? "" : e : r(t);
+  }, Sr;
+}
+var Br, ze;
+function An() {
+  return ze || (ze = 1, Br = {
+    IndexSizeError: {
+      s: "INDEX_SIZE_ERR",
+      c: 1,
+      m: 1
+    },
+    DOMStringSizeError: {
+      s: "DOMSTRING_SIZE_ERR",
+      c: 2,
+      m: 0
+    },
+    HierarchyRequestError: {
+      s: "HIERARCHY_REQUEST_ERR",
+      c: 3,
+      m: 1
+    },
+    WrongDocumentError: {
+      s: "WRONG_DOCUMENT_ERR",
+      c: 4,
+      m: 1
+    },
+    InvalidCharacterError: {
+      s: "INVALID_CHARACTER_ERR",
+      c: 5,
+      m: 1
+    },
+    NoDataAllowedError: {
+      s: "NO_DATA_ALLOWED_ERR",
+      c: 6,
+      m: 0
+    },
+    NoModificationAllowedError: {
+      s: "NO_MODIFICATION_ALLOWED_ERR",
+      c: 7,
+      m: 1
+    },
+    NotFoundError: {
+      s: "NOT_FOUND_ERR",
+      c: 8,
+      m: 1
+    },
+    NotSupportedError: {
+      s: "NOT_SUPPORTED_ERR",
+      c: 9,
+      m: 1
+    },
+    InUseAttributeError: {
+      s: "INUSE_ATTRIBUTE_ERR",
+      c: 10,
+      m: 1
+    },
+    InvalidStateError: {
+      s: "INVALID_STATE_ERR",
+      c: 11,
+      m: 1
+    },
+    SyntaxError: {
+      s: "SYNTAX_ERR",
+      c: 12,
+      m: 1
+    },
+    InvalidModificationError: {
+      s: "INVALID_MODIFICATION_ERR",
+      c: 13,
+      m: 1
+    },
+    NamespaceError: {
+      s: "NAMESPACE_ERR",
+      c: 14,
+      m: 1
+    },
+    InvalidAccessError: {
+      s: "INVALID_ACCESS_ERR",
+      c: 15,
+      m: 1
+    },
+    ValidationError: {
+      s: "VALIDATION_ERR",
+      c: 16,
+      m: 0
+    },
+    TypeMismatchError: {
+      s: "TYPE_MISMATCH_ERR",
+      c: 17,
+      m: 1
+    },
+    SecurityError: {
+      s: "SECURITY_ERR",
+      c: 18,
+      m: 1
+    },
+    NetworkError: {
+      s: "NETWORK_ERR",
+      c: 19,
+      m: 1
+    },
+    AbortError: {
+      s: "ABORT_ERR",
+      c: 20,
+      m: 1
+    },
+    URLMismatchError: {
+      s: "URL_MISMATCH_ERR",
+      c: 21,
+      m: 1
+    },
+    QuotaExceededError: {
+      s: "QUOTA_EXCEEDED_ERR",
+      c: 22,
+      m: 1
+    },
+    TimeoutError: {
+      s: "TIMEOUT_ERR",
+      c: 23,
+      m: 1
+    },
+    InvalidNodeTypeError: {
+      s: "INVALID_NODE_TYPE_ERR",
+      c: 24,
+      m: 1
+    },
+    DataCloneError: {
+      s: "DATA_CLONE_ERR",
+      c: 25,
+      m: 1
+    }
+  }), Br;
+}
+var Cr, Qe;
+function hn() {
+  if (Qe)
+    return Cr;
+  Qe = 1;
+  var r = F(), t = Error, e = r("".replace), a = function(o) {
+    return String(new t(o).stack);
+  }("zxcasd"), n = /\n\s*at [^:]*:[^\n]*/, i = n.test(a);
+  return Cr = function(o, s) {
+    if (i && typeof o == "string" && !t.prepareStackTrace)
+      for (; s--; )
+        o = e(o, n, "");
+    return o;
+  }, Cr;
+}
+var Je;
+function gn() {
+  if (Je)
+    return Ge;
+  Je = 1;
+  var r = $(), t = D(), e = Ct(), a = Nt(), n = xt().f, i = Nr(), o = Dt(), s = dn(), c = pn(), f = An(), v = hn(), l = Ze(), d = Pt(), m = "DOMException", g = e("Error"), w = e(m), y = function() {
+    o(this, E);
+    var N = arguments.length, B = c(N < 1 ? void 0 : arguments[0]), X = c(N < 2 ? void 0 : arguments[1], "Error"), S = new w(B, X), P = new g(B);
+    return P.name = m, n(S, "stack", a(1, v(P.stack, 1))), s(S, this, y), S;
+  }, E = y.prototype = w.prototype, b = "stack" in new g(m), u = "stack" in new w(1, 2), p = w && l && Object.getOwnPropertyDescriptor(t, m), A = !!p && !(p.writable && p.configurable), _ = b && !A && !u;
+  r({
+    global: !0,
+    constructor: !0,
+    forced: d || _
+  }, {
+    // TODO: fix export logic
+    DOMException: _ ? y : w
+  });
+  var h = e(m), T = h.prototype;
+  if (T.constructor !== h) {
+    d || n(T, "constructor", a(1, h));
+    for (var O in f)
+      if (i(f, O)) {
+        var I = f[O], q = I.s;
+        i(h, q) || n(h, q, a(6, I.c));
+      }
+  }
+  return Ge;
+}
+gn();
+const En = /* @__PURE__ */ new Date("2026-01-06T20:22:33.853Z"), xr = "Please visit https://www.react-pdf.dev/manage-license/ to generate a new license key.", V = {
+  invalidLicense: `You are currently using without a valid license. ${xr}`,
+  mismatchedDomain: `Your license key is not valid for the current domain / IP. ${xr}`,
+  expired: `Your license key has expired. ${xr}`,
   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 Tn(r) {
+  const t = r.replace(/-----BEGIN PUBLIC KEY-----/, "").replace(/-----END PUBLIC KEY-----/, "").replace(/\s+/g, ""), e = atob(t), a = new Uint8Array(e.length);
+  for (let n = 0; n < e.length; n++)
+    a[n] = e.charCodeAt(n);
+  return a.buffer;
 }
-function S(r) {
+function _n(r) {
   const t = atob(r), e = new Uint8Array(t.length);
-  for (let n = 0; n < t.length; n++)
-    e[n] = t.charCodeAt(n);
+  for (let a = 0; a < t.length; a++)
+    e[a] = t.charCodeAt(a);
   return e.buffer;
 }
-async function I(r, t = "SHA-256") {
+async function Rn(r, t = "SHA-256") {
   try {
-    const { data: e, signature: n } = JSON.parse(atob(r)), i = L(`-----BEGIN PUBLIC KEY-----
+    const {
+      data: e,
+      signature: a
+    } = JSON.parse(atob(r)), n = Tn(`-----BEGIN PUBLIC KEY-----
 MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvIokvErJ0Fctu0jduSAx
 gr+5Har/VSuZLlOunS28hnlqqA+OF1apHL7RYkjBosS15yvviYdLrVWYHpHnoY4b
 HLQ9I6YX6FMB9T/VbB4xLdVdKvfi8r49aTScl5EKuSpgpPgz2VSJTfvVGcRuth/Y
@@ -29,82 +1126,104 @@ Bm7PPGYdL2l2gvKDxchmmsHFPukGki9L4JOUeIVX0GXAxabENckaEH/iC1NZhX+W
 vXnpHeHuIIKlZ16LSivXNgo6BH2Z3GFdg4G3cAaXr6qNP8fsacYNqv2SpTW1viFD
 vzcGRabN25gpJAp9/syeScefWH3OiJY1lmw88oTiJbjIoiq6AkPhfn3G9mF54nvR
 kwIDAQAB
------END PUBLIC KEY-----`), a = await window.crypto.subtle.importKey(
+-----END PUBLIC KEY-----`), i = await window.crypto.subtle.importKey(
       "spki",
       // str2ab(publicKeyContent), // Convert PEM string to ArrayBuffer
-      i,
-      { name: "RSA-PSS", hash: t },
+      n,
+      {
+        name: "RSA-PSS",
+        hash: t
+      },
       !0,
       ["verify"]
     );
     if (!await window.crypto.subtle.verify(
-      { name: "RSA-PSS", saltLength: 32 },
-      a,
-      S(n),
+      {
+        name: "RSA-PSS",
+        saltLength: 32
+      },
+      i,
+      _n(a),
       // Convert signature to ArrayBuffer
       new TextEncoder().encode(atob(e))
     ))
-      throw new Error(s.invalidSignature);
+      throw new Error(V.invalidSignature);
     return JSON.parse(atob(e));
   } catch {
-    throw new Error(s.invalidLicense);
+    throw new Error(V.invalidLicense);
   }
 }
-const y = (r, t) => r === "specific" ? t === window.location.host : window.location.host.includes(t), u = {
+const mn = (r, t) => r === "specific" ? t === window.location.host : window.location.host.includes(t), Dr = {
   isValid: !0,
-  invalidatedMessage: s.invalidLicense,
+  invalidatedMessage: V.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;
+}, xn = (r) => {
+  const [t, e] = Lt(Dr), a = Mt(async () => {
+    if (e((g) => ({
+      ...g,
+      validating: !0
+    })), !r)
+      throw e({
+        ...Dr,
+        validating: !1
+      }), new Error(V.invalidLicense);
+    let n;
     try {
-      i = await I(r);
-    } catch (c) {
-      throw l.warn(c.message), new Error(c.message);
+      n = await Rn(r);
+    } catch (g) {
+      throw z.warn(g.message), new Error(g.message);
     }
-    l.debug(">>> validatedLicense", i);
-    const { avu: a, exp: o, dmt: m, dm: w, t: f } = i;
+    z.debug(">>> validatedLicense", n);
+    const {
+      avu: i,
+      exp: o,
+      dmt: s,
+      dm: c,
+      t: f
+    } = n;
     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)
+    const v = new Date(o * 1e3), l = (/* @__PURE__ */ new Date()).getTime();
+    if (v.getTime() < l)
+      throw new Error(V.expired);
+    if (!i)
       throw new Error("License is missing available until version timestamp");
-    if (a > Number.MAX_SAFE_INTEGER / 1e3)
+    if (i > 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);
+    const d = new Date(i * 1e3);
+    if (z.debug("availableUntilTimestamp", d), d.getTime() < En.getTime())
+      throw new Error(V.exceededVersion);
+    if (!mn(s, c))
+      throw new Error(V.mismatchedDomain);
     return {
       isValid: !0,
       type: f,
       invalidatedMessage: void 0
     };
   }, [r]);
-  return A(() => {
-    n().then(({ isValid: i, type: a, invalidatedMessage: o }) => {
+  return Ft(() => {
+    a().then(({
+      isValid: n,
+      type: i,
+      invalidatedMessage: o
+    }) => {
       e({
-        isValid: i,
-        type: a,
+        isValid: n,
+        type: i,
         invalidatedMessage: o,
         validating: !1
       });
-    }).catch((i) => {
+    }).catch((n) => {
       e({
-        ...u,
+        ...Dr,
         isValid: !1,
         validating: !1
-      }), l.warn(i.message);
+      }), z.warn(n.message);
     });
-  }, [n]), t;
+  }, [a]), t;
 };
 export {
-  x as useLicense
+  xn as useLicense
 };