@broadpaper/pdf 0.1.1

package/dist/chunk-4YSTS7DA.js

@@ -0,0 +1,1160 @@
+// ../license/src/encoding.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var LOOKUP = /* @__PURE__ */ (() => {
+  const t = new Int8Array(128).fill(-1);
+  for (let i = 0; i < ALPHABET.length; i++) t[ALPHABET.charCodeAt(i)] = i;
+  t["+".charCodeAt(0)] = 62;
+  t["/".charCodeAt(0)] = 63;
+  return t;
+})();
+function base64UrlToBytes(text) {
+  let end = text.length;
+  while (end > 0 && text[end - 1] === "=") end--;
+  const chars = [];
+  for (let i2 = 0; i2 < end; i2++) {
+    const code = text.charCodeAt(i2);
+    const value = code < 128 ? LOOKUP[code] : -1;
+    if (value < 0) throw new Error(`not base64: ${JSON.stringify(text[i2])} at ${i2}`);
+    chars.push(value);
+  }
+  if (chars.length % 4 === 1) throw new Error("not base64: truncated");
+  const out = new Uint8Array(Math.floor(chars.length * 3 / 4));
+  let o = 0;
+  let i = 0;
+  for (; i + 3 < chars.length; i += 4) {
+    const n = chars[i] << 18 | chars[i + 1] << 12 | chars[i + 2] << 6 | chars[i + 3];
+    out[o++] = n >>> 16 & 255;
+    out[o++] = n >>> 8 & 255;
+    out[o++] = n & 255;
+  }
+  const rest = chars.length - i;
+  if (rest === 2) {
+    out[o++] = (chars[i] << 18 | chars[i + 1] << 12) >>> 16;
+  } else if (rest === 3) {
+    const n = chars[i] << 18 | chars[i + 1] << 12 | chars[i + 2] << 6;
+    out[o++] = n >>> 16 & 255;
+    out[o++] = n >>> 8 & 255;
+  }
+  return out;
+}
+var encoder = /* @__PURE__ */ new TextEncoder();
+var decoder = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
+var utf8ToBytes = (text) => encoder.encode(text);
+var bytesToUtf8 = (bytes) => decoder.decode(bytes);
+
+// ../license/src/format.ts
+var FORMAT_PREFIX = "BP1";
+var LicenseFormatError = class extends Error {
+  constructor(message, kind = "invalid") {
+    super(message);
+    this.kind = kind;
+    this.name = "LicenseFormatError";
+  }
+  kind;
+};
+var ENTITLEMENTS = ["internal", "saas"];
+function normalizeLicense(license) {
+  return license.replace(/\s+/g, "");
+}
+function parseLicense(license) {
+  const text = normalizeLicense(license);
+  if (!text) throw new LicenseFormatError("the licence string is empty");
+  const parts = text.split(".");
+  if (parts.length !== 3) throw new LicenseFormatError(`expected three dot-separated parts, found ${parts.length}`);
+  const [prefix, encodedPayload, encodedSignature] = parts;
+  if (prefix !== FORMAT_PREFIX) {
+    const known = /^BP\d+$/.test(prefix);
+    throw new LicenseFormatError(
+      known ? `licence format ${prefix} is newer than this version of BroadPaper, which reads ${FORMAT_PREFIX}` : `unrecognised licence prefix ${JSON.stringify(prefix)}`,
+      known ? "unsupported" : "invalid"
+    );
+  }
+  if (!encodedPayload || !encodedSignature) throw new LicenseFormatError("the licence string has an empty part");
+  let json;
+  let signature;
+  try {
+    json = bytesToUtf8(base64UrlToBytes(encodedPayload));
+    signature = base64UrlToBytes(encodedSignature);
+  } catch (e) {
+    throw new LicenseFormatError(`the licence string is not valid base64 (${e.message})`);
+  }
+  if (signature.length !== 64) throw new LicenseFormatError(`an Ed25519 signature is 64 bytes, this one is ${signature.length}`);
+  let raw;
+  try {
+    raw = JSON.parse(json);
+  } catch {
+    throw new LicenseFormatError("the licence payload is not valid JSON");
+  }
+  return {
+    prefix,
+    signedText: `${prefix}.${encodedPayload}`,
+    encodedPayload,
+    signature,
+    payload: readPayload(raw)
+  };
+}
+function readPayload(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new LicenseFormatError("the licence payload is not an object");
+  const o = raw;
+  const version = o.version;
+  if (version !== 1) {
+    const numeric = typeof version === "number" && Number.isInteger(version) && version > 1;
+    throw new LicenseFormatError(
+      numeric ? `licence payload version ${version} is newer than this version of BroadPaper, which reads version 1` : "the licence payload has no usable version",
+      numeric ? "unsupported" : "invalid"
+    );
+  }
+  const text = (key) => {
+    const value = o[key];
+    if (typeof value !== "string" || value === "") throw new LicenseFormatError(`the licence payload is missing ${key}`);
+    return value;
+  };
+  const seconds = (key) => {
+    const value = o[key];
+    if (typeof value !== "number" || !Number.isFinite(value)) throw new LicenseFormatError(`the licence payload is missing ${key}`);
+    return value;
+  };
+  const entitlement = text("entitlement");
+  if (!ENTITLEMENTS.includes(entitlement)) {
+    throw new LicenseFormatError(`this version of BroadPaper does not know the entitlement ${JSON.stringify(entitlement)}`, "unsupported");
+  }
+  return {
+    ...o,
+    version: 1,
+    keyId: text("keyId"),
+    licenseId: text("licenseId"),
+    customerId: text("customerId"),
+    customerName: text("customerName"),
+    product: text("product"),
+    entitlement,
+    issuedAt: seconds("issuedAt"),
+    expiresAt: seconds("expiresAt")
+  };
+}
+
+// ../../node_modules/.pnpm/@noble+ed25519@3.2.0/node_modules/@noble/ed25519/index.js
+var freeze = Object.freeze;
+var P = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn;
+var N = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn;
+var _d = 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n;
+var Gx = 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an;
+var Gy = 0x6666666666666666666666666666666666666666666666666666666666666658n;
+var _a = P - 1n;
+var ed25519_CURVE = freeze({
+  p: P,
+  n: N,
+  h: 8n,
+  a: _a,
+  d: _d,
+  Gx,
+  Gy
+});
+var LEN = 32;
+var isBytes = (a) => {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && a.BYTES_PER_ELEMENT === 1;
+};
+var abytes = (value, length, title = "") => {
+  if (isBytes(value) && (length === void 0 || value.length === length))
+    return value;
+  const bytes = isBytes(value);
+  const ofLen = length !== void 0 ? ` of length ${length}` : "";
+  const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+  const message = (title ? `"${title}" ` : "") + "expected Uint8Array" + ofLen + ", got " + got;
+  if (!bytes)
+    throw new TypeError(message);
+  throw new RangeError(message);
+};
+var snapshotBytes = (value, title = "", length) => Uint8Array.from(abytes(value, length, title));
+var padh = (n, pad) => n.toString(16).padStart(pad, "0");
+var bytesToHex = (bytes) => {
+  let hex = "";
+  for (const byte of abytes(bytes))
+    hex += padh(byte, 2);
+  return hex;
+};
+var hexToBytes = (hex) => {
+  const e = "hex invalid";
+  if (typeof hex !== "string")
+    throw new TypeError(e);
+  if (hex.length % 2 || !/^[\da-f]*$/i.test(hex))
+    throw new RangeError(e);
+  const array = new Uint8Array(hex.length / 2);
+  for (let ai = 0, hi = 0; ai < array.length; ai++, hi += 2) {
+    const n1 = hex.charCodeAt(hi);
+    const n2 = hex.charCodeAt(hi + 1);
+    array[ai] = ((n1 & 15) + (n1 >> 6) * 9) * 16 + (n2 & 15) + (n2 >> 6) * 9;
+  }
+  return array;
+};
+var concatBytes = (...arrays) => {
+  let sum = 0;
+  for (const a of arrays)
+    sum += abytes(a).length;
+  const res = new Uint8Array(sum);
+  let pad = 0;
+  for (const a of arrays) {
+    res.set(a, pad);
+    pad += a.length;
+  }
+  return res;
+};
+var arange = (n, min, max, msg = "bad number: out of range") => {
+  if (typeof n !== "bigint")
+    throw new TypeError(msg);
+  if (min <= n && n < max)
+    return n;
+  throw new RangeError(msg);
+};
+var mod = (a, b = P) => (a %= b) >= 0n ? a : b + a;
+var P_MASK = (1n << 255n) - 1n;
+var modP = (num) => {
+  if (num < 0n)
+    throw new RangeError("negative coordinate");
+  let r = (num >> 255n) * 19n + (num & P_MASK);
+  r = (r >> 255n) * 19n + (r & P_MASK);
+  return r % P;
+};
+var modN = (a) => mod(a, N);
+var invert = (number, modulo) => {
+  if (number === 0n)
+    throw new Error("invert: expected non-zero number");
+  if (modulo <= 1n)
+    throw new Error("invert: expected modulus > 1, got " + modulo);
+  let a = mod(number, modulo);
+  let b = modulo;
+  let x = 0n, u = 1n;
+  while (a !== 0n) {
+    const q = b / a;
+    const r = b - a * q;
+    const m = x - u * q;
+    b = a, a = r, x = u, u = m;
+  }
+  const gcd = b;
+  if (gcd !== 1n)
+    throw new Error("invert: does not exist");
+  return mod(x, modulo);
+};
+var _hash = (name) => {
+  const fn = hashes[name];
+  if (typeof fn !== "function")
+    throw new Error("hashes." + name + " not set");
+  return fn;
+};
+var callHashAsync = async (name, ...m) => abytes(await _hash(name)(concatBytes(...m)), 64, "digest");
+var apoint = (p) => {
+  if (p instanceof Point)
+    return p;
+  throw new TypeError("Point expected");
+};
+var B256 = 2n ** 256n;
+var Point = class _Point {
+  static BASE;
+  static ZERO;
+  X;
+  Y;
+  Z;
+  T;
+  // Constructor only bounds-checks and freezes XYZT coordinates; it does not prove the point is
+  // on-curve or that T matches X*Y/Z.
+  constructor(X, Y, Z, T) {
+    const max = B256;
+    this.X = arange(X, 0n, max);
+    this.Y = arange(Y, 0n, max);
+    this.Z = arange(Z, 1n, max);
+    this.T = arange(T, 0n, max);
+    freeze(this);
+  }
+  static CURVE() {
+    return ed25519_CURVE;
+  }
+  static fromAffine(p) {
+    return new _Point(p.x, p.y, 1n, modP(p.x * p.y));
+  }
+  /** RFC8032 5.1.3: Uint8Array to Point. */
+  static fromBytes(bytes, zip215 = false) {
+    const normed = snapshotBytes(bytes, "point", LEN);
+    const lastByte = normed[31];
+    normed[31] = lastByte & ~128;
+    const y = bytesToNumberLE(normed);
+    if (!zip215)
+      arange(y, 0n, P);
+    const y2 = modP(y * y);
+    const u = mod(y2 - 1n);
+    const v = modP(_d * y2 + 1n);
+    let { isValid, value: x } = uvRatio(u, v);
+    if (!isValid)
+      throw new Error("bad point: y not sqrt");
+    const isLastByteOdd = !!(lastByte & 128);
+    if (!zip215 && x === 0n && isLastByteOdd)
+      throw new Error("bad point: x==0, isLastByteOdd");
+    if (isLastByteOdd !== !!(x & 1n))
+      x = mod(-x);
+    return new _Point(x, y, 1n, modP(x * y));
+  }
+  static fromHex(hex, zip215) {
+    return _Point.fromBytes(hexToBytes(hex), zip215);
+  }
+  get x() {
+    return this.toAffine().x;
+  }
+  get y() {
+    return this.toAffine().y;
+  }
+  /** Checks if the point is valid and on-curve. */
+  assertValidity() {
+    const a = _a;
+    const d = _d;
+    const p = this;
+    if (p.is0())
+      throw new Error("bad point: ZERO");
+    const { X, Y, Z, T } = p;
+    const X2 = modP(X * X);
+    const Y2 = modP(Y * Y);
+    const Z2 = modP(Z * Z);
+    const Z4 = modP(Z2 * Z2);
+    const aX2 = modP(X2 * a);
+    const left = modP(Z2 * (aX2 + Y2));
+    const right = mod(Z4 + modP(d * modP(X2 * Y2)));
+    if (left !== right)
+      throw new Error("bad point: equation left != right (1)");
+    const XY = modP(X * Y);
+    const ZT = modP(Z * T);
+    if (XY !== ZT)
+      throw new Error("bad point: equation left != right (2)");
+    return this;
+  }
+  /** Equality check: compare points P&Q. */
+  equals(other) {
+    const { X: X1, Y: Y1, Z: Z1 } = this;
+    const { X: X2, Y: Y2, Z: Z2 } = apoint(other);
+    return modP(X1 * Z2) === modP(X2 * Z1) && modP(Y1 * Z2) === modP(Y2 * Z1);
+  }
+  is0() {
+    return this.equals(I);
+  }
+  /** Flip point over y coordinate. */
+  negate() {
+    return new _Point(mod(-this.X), this.Y, this.Z, mod(-this.T));
+  }
+  /** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
+  double() {
+    const { X: X1, Y: Y1, Z: Z1 } = this;
+    const a = _a;
+    const A = modP(X1 * X1);
+    const B = modP(Y1 * Y1);
+    const C = modP(2n * Z1 * Z1);
+    const D = modP(a * A);
+    const x1y1 = mod(X1 + Y1);
+    const E = mod(modP(x1y1 * x1y1) - A - B);
+    const G2 = mod(D + B);
+    const F = mod(G2 - C);
+    const H = mod(D - B);
+    const X3 = modP(E * F);
+    const Y3 = modP(G2 * H);
+    const T3 = modP(E * H);
+    const Z3 = modP(F * G2);
+    return new _Point(X3, Y3, Z3, T3);
+  }
+  /** Point addition. Complete formula. Cost: `9M + 1*a + 1*d + 7add`. */
+  add(other) {
+    const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
+    const { X: X2, Y: Y2, Z: Z2, T: T2 } = apoint(other);
+    const a = _a;
+    const d = _d;
+    const A = modP(X1 * X2);
+    const B = modP(Y1 * Y2);
+    const C = modP(modP(T1 * d) * T2);
+    const D = modP(Z1 * Z2);
+    const E = mod(modP(mod(X1 + Y1) * mod(X2 + Y2)) - A - B);
+    const F = mod(D - C);
+    const G2 = mod(D + C);
+    const H = mod(B - modP(a * A));
+    const X3 = modP(E * F);
+    const Y3 = modP(G2 * H);
+    const T3 = modP(E * H);
+    const Z3 = modP(F * G2);
+    return new _Point(X3, Y3, Z3, T3);
+  }
+  subtract(other) {
+    return this.add(apoint(other).negate());
+  }
+  /**
+   * Point-by-scalar multiplication. Safe mode requires `1 <= n < CURVE.n`.
+   * Unsafe mode additionally permits `n = 0` and returns the identity point for that case.
+   * Uses {@link wNAF} for base point.
+   * Uses fake point to mitigate side-channel leakage.
+   * @param n - scalar by which point is multiplied
+   * @param safe - safe mode guards against timing attacks; unsafe mode is faster
+   */
+  multiply(n, safe = true) {
+    if (!safe && n === 0n)
+      return I;
+    arange(n, 1n, N);
+    if (!safe && this.is0())
+      return I;
+    if (n === 1n)
+      return this;
+    if (this.equals(G))
+      return wNAF(n).p;
+    let p = I;
+    let f = G;
+    let d = this;
+    for (let i = 0; safe ? i < 256 : n > 0n; i++) {
+      if (n & 1n)
+        p = p.add(d);
+      else if (safe)
+        f = f.add(d);
+      d = d.double();
+      n >>= 1n;
+    }
+    return p;
+  }
+  multiplyUnsafe(scalar) {
+    return this.multiply(scalar, false);
+  }
+  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+  toAffine() {
+    const { X, Y, Z } = this;
+    if (this.equals(I))
+      return { x: 0n, y: 1n };
+    const iz = invert(Z, P);
+    if (modP(Z * iz) !== 1n)
+      throw new Error("invalid inverse");
+    return { x: modP(X * iz), y: modP(Y * iz) };
+  }
+  toBytes() {
+    const { x, y } = this.toAffine();
+    const b = numTo32bLE(y);
+    b[31] |= x & 1n ? 128 : 0;
+    return b;
+  }
+  toHex() {
+    return bytesToHex(this.toBytes());
+  }
+  clearCofactor() {
+    return this.multiply(8n, false);
+  }
+  isSmallOrder() {
+    return this.clearCofactor().is0();
+  }
+  isTorsionFree() {
+    return this.multiply(N / 2n, false).double().add(this).is0();
+  }
+};
+var G = new Point(Gx, Gy, 1n, mod(Gx * Gy));
+var I = new Point(0n, 1n, 1n, 0n);
+Point.BASE = G;
+Point.ZERO = I;
+var numTo32bLE = (num) => hexToBytes(padh(arange(num, 0n, B256), 64)).reverse();
+var bytesToNumberLE = (b) => BigInt("0x" + bytesToHex(Uint8Array.from(abytes(b)).reverse()));
+var pow2 = (x, power) => {
+  let r = x;
+  while (power-- > 0) {
+    r = modP(r * r);
+  }
+  return r;
+};
+var pow_2_252_3 = (x) => {
+  const x2 = modP(x * x);
+  const b2 = modP(x2 * x);
+  const b4 = modP(pow2(b2, 2) * b2);
+  const b5 = modP(pow2(b4, 1) * x);
+  const b10 = modP(pow2(b5, 5) * b5);
+  const b20 = modP(pow2(b10, 10) * b10);
+  const b40 = modP(pow2(b20, 20) * b20);
+  const b80 = modP(pow2(b40, 40) * b40);
+  const b160 = modP(pow2(b80, 80) * b80);
+  const b240 = modP(pow2(b160, 80) * b80);
+  const b250 = modP(pow2(b240, 10) * b10);
+  return modP(pow2(b250, 2) * x);
+};
+var RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n;
+var uvRatio = (u, v) => {
+  const v3 = modP(v * modP(v * v));
+  const v7 = modP(modP(v3 * v3) * v);
+  const pow = pow_2_252_3(modP(u * v7));
+  let x = modP(u * modP(v3 * pow));
+  const vx2 = modP(v * modP(x * x));
+  const root1 = x;
+  const root2 = modP(x * RM1);
+  const useRoot1 = vx2 === u;
+  const useRoot2 = vx2 === mod(-u);
+  const noRoot = vx2 === mod(-u * RM1);
+  if (useRoot1)
+    x = root1;
+  if (useRoot2 || noRoot)
+    x = root2;
+  if ((mod(x) & 1n) === 1n)
+    x = mod(-x);
+  return { isValid: useRoot1 || useRoot2, value: x };
+};
+var modL_LE = (hash) => modN(bytesToNumberLE(hash));
+var hashFinishAsync = async (res) => res[1](await callHashAsync("sha512Async", res[0]));
+var getZip215 = (options) => {
+  if (options === null || typeof options !== "object")
+    throw new TypeError("expected valid options object");
+  return options.zip215 ?? true;
+};
+var _verify = (sig, msg, publicKey, options) => {
+  sig = abytes(sig, 64, "signature");
+  msg = abytes(msg, void 0, "message");
+  publicKey = abytes(publicKey, LEN, "publicKey");
+  const zip215 = getZip215(options);
+  const r = sig.subarray(0, LEN);
+  const s = bytesToNumberLE(sig.subarray(LEN, 64));
+  let A, R, SB;
+  let hashable = Uint8Array.of();
+  let finished = false;
+  try {
+    A = Point.fromBytes(publicKey, zip215);
+    R = Point.fromBytes(r, zip215);
+    SB = G.multiply(s, false);
+    hashable = concatBytes(r, publicKey, msg);
+    finished = true;
+  } catch (error) {
+  }
+  const finish = (hashed) => {
+    if (!finished)
+      return false;
+    if (!zip215 && A.isSmallOrder())
+      return false;
+    const k = modL_LE(hashed);
+    const RkA = R.add(A.multiply(k, false));
+    return RkA.subtract(SB).clearCofactor().is0();
+  };
+  return [hashable, finish];
+};
+var verifyAsync = async (signature, message, publicKey, opts = {}) => hashFinishAsync(_verify(signature, message, publicKey, opts));
+var hashes = {
+  sha512Async: async (message) => {
+    const s = globalThis?.crypto?.subtle;
+    if (!s)
+      throw new Error("crypto.subtle must be defined, consider polyfill");
+    return new Uint8Array(await s.digest("SHA-512", concatBytes(message)));
+  },
+  sha512: void 0
+};
+var precompute = () => {
+  const points = [];
+  let p = G;
+  let b;
+  for (let w = 0; w < 33; w++) {
+    b = p;
+    points.push(b);
+    for (let i = 1; i < 128; i++) {
+      b = b.add(p);
+      points.push(b);
+    }
+    p = b.double();
+  }
+  return points;
+};
+var Gpows = void 0;
+var ctneg = (cnd, p) => {
+  const n = p.negate();
+  return cnd ? n : p;
+};
+var wNAF = (n) => {
+  const comp = Gpows || (Gpows = precompute());
+  let p = I;
+  let f = G;
+  for (let w = 0; w < 33; w++) {
+    let wbits = Number(n & 255n);
+    n >>= 8n;
+    if (wbits > 128) {
+      wbits -= 256;
+      n += 1n;
+    }
+    const off = w * 128;
+    const offP = off + Math.abs(wbits) - 1;
+    const isOddW = w % 2 !== 0;
+    const isNeg = wbits < 0;
+    if (wbits === 0) {
+      f = f.add(ctneg(isOddW, comp[off]));
+    } else {
+      p = p.add(ctneg(isNeg, comp[offP]));
+    }
+  }
+  if (n !== 0n)
+    throw new Error("invalid wnaf");
+  return { p, f };
+};
+
+// ../license/src/trusted-keys.ts
+var TRUSTED_KEYS = [
+  { keyId: "bp-2026", publicKey: "woKmWyIazae7SpGhi4dwA7zNK1lWdboq88Rl5xscTs4", note: "production, generated 2026-09-08" }
+];
+
+// ../license/src/types.ts
+var PRODUCT = "broadpaper-sdk";
+
+// ../license/src/verify.ts
+var DEFAULT_GRACE_PERIOD_DAYS = 30;
+var DAY_MS = 864e5;
+function unlicensed() {
+  return {
+    state: "unlicensed",
+    licensed: false,
+    payload: null,
+    entitlement: null,
+    expiresAt: null,
+    daysRemaining: null,
+    message: "No BroadPaper licence is configured, so PDFs carry the evaluation watermark. Everything else works; see https://www.broadpaper.com/docs/guide/licensing."
+  };
+}
+function failure(state, message, payload = null) {
+  return {
+    state,
+    licensed: false,
+    payload,
+    entitlement: null,
+    expiresAt: payload ? new Date(payload.expiresAt * 1e3) : null,
+    daysRemaining: null,
+    message
+  };
+}
+async function verifyLicense(license, options = {}) {
+  if (!license || !license.trim()) return unlicensed();
+  let parsed;
+  try {
+    parsed = parseLicense(license);
+  } catch (e) {
+    if (e instanceof LicenseFormatError) {
+      return failure(
+        e.kind,
+        e.kind === "unsupported" ? `This BroadPaper licence needs a newer version of the SDK (${e.message}). Update @broadpaper/* or the PDF will carry the evaluation watermark.` : `The BroadPaper licence could not be read (${e.message}), so PDFs carry the evaluation watermark.`
+      );
+    }
+    throw e;
+  }
+  const { payload } = parsed;
+  if (payload.product !== PRODUCT) {
+    return failure(
+      "invalid",
+      `This licence is for ${JSON.stringify(payload.product)}, not the BroadPaper SDK, so PDFs carry the evaluation watermark.`,
+      payload
+    );
+  }
+  const key = findKey(payload.keyId, options.trustedKeys);
+  if (!key) {
+    return failure(
+      "untrusted",
+      `This BroadPaper licence was signed with key ${JSON.stringify(payload.keyId)}, which this build does not trust. A licence issued for development is not honoured by a production build; check BROADPAPER_LICENSE points at the right one.`,
+      payload
+    );
+  }
+  let signatureOk = false;
+  try {
+    signatureOk = await verifyAsync(parsed.signature, utf8ToBytes(parsed.signedText), base64UrlToBytes(key.publicKey));
+  } catch {
+    signatureOk = false;
+  }
+  if (!signatureOk) {
+    return failure("invalid", "This BroadPaper licence failed its signature check \u2014 it has been altered or truncated. PDFs carry the evaluation watermark.", payload);
+  }
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const expiresAt = new Date(payload.expiresAt * 1e3);
+  const graceDays = options.gracePeriodDays ?? DEFAULT_GRACE_PERIOD_DAYS;
+  const msRemaining = expiresAt.getTime() - now.getTime();
+  const daysRemaining = Math.floor(msRemaining / DAY_MS);
+  if (msRemaining > 0) {
+    return {
+      state: "active",
+      licensed: true,
+      payload,
+      entitlement: payload.entitlement,
+      expiresAt,
+      daysRemaining,
+      message: null
+    };
+  }
+  if (msRemaining > -graceDays * DAY_MS) {
+    const daysOver = Math.max(1, Math.ceil(-msRemaining / DAY_MS));
+    return {
+      state: "grace",
+      licensed: true,
+      payload,
+      entitlement: payload.entitlement,
+      expiresAt,
+      daysRemaining,
+      message: `The BroadPaper licence for ${payload.customerName} expired ${daysOver} day${daysOver === 1 ? "" : "s"} ago and is inside its ${graceDays}-day grace period. Renew it and copy the new licence from your account, or PDFs will start carrying the evaluation watermark.`
+    };
+  }
+  return failure(
+    "expired",
+    `The BroadPaper licence for ${payload.customerName} expired on ${expiresAt.toISOString().slice(0, 10)} and its ${graceDays}-day grace period has passed, so PDFs carry the evaluation watermark. Renewing issues a new licence in your BroadPaper account.`,
+    payload
+  );
+}
+function findKey(keyId, extra) {
+  return extra?.find((k) => k.keyId === keyId) ?? TRUSTED_KEYS.find((k) => k.keyId === keyId);
+}
+
+// ../license/src/config.ts
+var STORE_KEY = /* @__PURE__ */ Symbol.for("broadpaper.license.store");
+function store() {
+  const g = globalThis;
+  let s = g[STORE_KEY];
+  if (!s) {
+    s = { config: {}, cache: null, logged: /* @__PURE__ */ new Set() };
+    g[STORE_KEY] = s;
+  }
+  return s;
+}
+function configure(config) {
+  const s = store();
+  s.config = { ...s.config, ...config };
+  s.cache = null;
+  s.logged.clear();
+}
+function getConfig() {
+  return { ...store().config };
+}
+var BroadPaper = { configure, getConfig };
+function env(name) {
+  const p = globalThis.process;
+  const value = p?.env?.[name];
+  return value && value.trim() ? value : void 0;
+}
+function trustedKeysFromEnv() {
+  const raw = env("BROADPAPER_TRUSTED_KEYS");
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) throw new Error("expected a JSON array");
+    return parsed.map((entry, i) => {
+      const k = entry;
+      if (typeof k?.keyId !== "string" || typeof k?.publicKey !== "string") throw new Error(`entry ${i} needs keyId and publicKey`);
+      return { keyId: k.keyId, publicKey: k.publicKey };
+    });
+  } catch (e) {
+    warn(`BROADPAPER_TRUSTED_KEYS could not be read (${e.message}); it is being ignored.`);
+    return [];
+  }
+}
+function warn(message) {
+  const s = store();
+  if (s.logged.has(message)) return;
+  s.logged.add(message);
+  const logger = s.config.logger;
+  if (logger === null) return;
+  const line = `[BroadPaper] ${message}`;
+  if (logger) logger(line);
+  else console.warn(line);
+}
+async function resolveLicenseStatus(options = {}) {
+  const s = store();
+  const config = s.config;
+  const license = options.license !== void 0 ? options.license : config.license ?? env("BROADPAPER_LICENSE") ?? null;
+  const trustedKeys = [...options.trustedKeys ?? [], ...config.trustedKeys ?? [], ...trustedKeysFromEnv()];
+  const gracePeriodDays = options.gracePeriodDays ?? config.gracePeriodDays;
+  if (!license) {
+    const status = unlicensed();
+    if (status.message) warn(status.message);
+    return status;
+  }
+  const verify = () => verifyLicense(license, { ...options.now ? { now: options.now } : {}, trustedKeys, ...gracePeriodDays !== void 0 ? { gracePeriodDays } : {} }).then((status) => {
+    if (status.message) warn(status.message);
+    return status;
+  });
+  if (options.now || options.license !== void 0) return verify();
+  const key = `${license}|${trustedKeys.map((k) => k.keyId).join(",")}|${gracePeriodDays ?? ""}`;
+  if (s.cache?.key !== key) s.cache = { key, status: verify() };
+  return s.cache.status;
+}
+
+// ../license/src/watermark.ts
+var EVALUATION_WATERMARK = {
+  text: "BroadPaper Evaluation Copy",
+  fontSize: 44,
+  angle: -35,
+  color: "#c8102e",
+  opacity: 0.12
+};
+function watermarkFor(status) {
+  return status.licensed ? null : EVALUATION_WATERMARK;
+}
+function producerString(status) {
+  if (!status.licensed || !status.payload) return "BroadPaper (evaluation)";
+  return `BroadPaper (${status.payload.licenseId})`;
+}
+
+// src/server/ssrf.ts
+import { lookup } from "dns/promises";
+import { isIP } from "net";
+var PRIVATE_V4 = [
+  [/^10\./, "10/8"],
+  [/^127\./, "loopback"],
+  [/^169\.254\./, "link-local"],
+  [/^172\.(1[6-9]|2\d|3[01])\./, "172.16/12"],
+  [/^192\.168\./, "192.168/16"],
+  [/^0\./, "0/8"],
+  [/^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./, "CGNAT"]
+];
+function isPrivateAddress(ip) {
+  const kind = isIP(ip);
+  if (kind === 4) return PRIVATE_V4.some(([re]) => re.test(ip));
+  if (kind === 6) {
+    const lower = ip.toLowerCase();
+    if (lower === "::1" || lower === "::") return true;
+    if (lower.startsWith("fe80:") || lower.startsWith("fc") || lower.startsWith("fd")) return true;
+    const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
+    if (mapped) return isPrivateAddress(mapped[1]);
+    return false;
+  }
+  return false;
+}
+function hostAllowed(host, allowed) {
+  if (!allowed || allowed.length === 0) return false;
+  const h = host.toLowerCase();
+  return allowed.some((pattern) => {
+    const p = pattern.toLowerCase();
+    if (p === "*") return true;
+    if (p.startsWith("*.")) return h === p.slice(2) || h.endsWith(p.slice(1));
+    return h === p;
+  });
+}
+async function decideRequest(url, policy, counter) {
+  if (url.startsWith("data:") || url === "about:blank") return { allow: true };
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    return { allow: false, reason: "invalid URL" };
+  }
+  if (u.protocol !== "http:" && u.protocol !== "https:") return { allow: false, reason: `scheme ${u.protocol} not allowed` };
+  if (++counter.count > (policy.maxRequests ?? 200)) return { allow: false, reason: "request limit exceeded" };
+  if (!hostAllowed(u.hostname, policy.allowedHosts)) return { allow: false, reason: `host ${u.hostname} not in allow-list` };
+  if (policy.blockPrivateNetworks !== false) {
+    const host = u.hostname.replace(/^\[|\]$/g, "");
+    if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".internal")) return { allow: false, reason: "private host" };
+    if (isIP(host)) {
+      if (isPrivateAddress(host)) return { allow: false, reason: "private address" };
+    } else {
+      try {
+        const results = await lookup(host, { all: true });
+        if (results.some((r) => isPrivateAddress(r.address))) return { allow: false, reason: "resolves to a private address" };
+      } catch {
+        return { allow: false, reason: "DNS lookup failed" };
+      }
+    }
+  }
+  return { allow: true };
+}
+
+// src/server/render-pdf.ts
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+// src/server/watermark.ts
+async function stampWatermark(doc, spec) {
+  const { StandardFonts, degrees, rgb } = await import("pdf-lib");
+  const font = await doc.embedFont(StandardFonts.HelveticaBold);
+  const color = hexToRgb(spec.color);
+  const radians = spec.angle * Math.PI / 180;
+  const width = font.widthOfTextAtSize(spec.text, spec.fontSize);
+  const height = font.heightAtSize(spec.fontSize);
+  for (const page of doc.getPages()) {
+    const { width: pw, height: ph } = page.getSize();
+    const x = pw / 2 - Math.cos(radians) * width / 2 + Math.sin(radians) * height / 2;
+    const y = ph / 2 - Math.sin(radians) * width / 2 - Math.cos(radians) * height / 2;
+    page.drawText(spec.text, {
+      x,
+      y,
+      size: spec.fontSize,
+      font,
+      color: rgb(color.r, color.g, color.b),
+      opacity: spec.opacity,
+      rotate: degrees(spec.angle)
+    });
+  }
+}
+function hexToRgb(hex) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return { r: 0.78, g: 0.06, b: 0.18 };
+  const n = parseInt(m[1], 16);
+  return { r: (n >> 16 & 255) / 255, g: (n >> 8 & 255) / 255, b: (n & 255) / 255 };
+}
+
+// src/server/render-pdf.ts
+var PdfRenderError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "PdfRenderError";
+  }
+  code;
+};
+var runtimeCache = null;
+async function loadRuntime(path) {
+  if (path) return readFile(path, "utf8");
+  if (runtimeCache) return runtimeCache;
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [join(here, "runtime.global.js"), join(here, "..", "dist", "runtime.global.js")];
+  for (const c of candidates) {
+    try {
+      runtimeCache = await readFile(c, "utf8");
+      return runtimeCache;
+    } catch {
+    }
+  }
+  throw new PdfRenderError("BroadPaper runtime bundle not found. Run `pnpm --filter @broadpaper/pdf build`.", "RUNTIME");
+}
+var BLANK_HTML = `<!doctype html><html><head><meta charset="utf-8"><title>BroadPaper</title></head><body></body></html>`;
+var PdfRenderer = class {
+  constructor(browser) {
+    this.browser = browser;
+  }
+  browser;
+  async render(opts) {
+    const started = Date.now();
+    const timeout = opts.timeoutMs ?? 6e4;
+    const runtime = await loadRuntime(opts.runtimePath);
+    let context = null;
+    try {
+      context = await this.browser.newContext({ javaScriptEnabled: true, offline: false, viewport: { width: 1200, height: 1600 }, deviceScaleFactor: 1, bypassCSP: false, locale: opts.locale ?? "en-GB", timezoneId: opts.timeZone });
+      context.setDefaultTimeout(timeout);
+      const counter = { count: 0 };
+      const policy = { allowedHosts: [], blockPrivateNetworks: true, maxRequests: 200, ...opts.network ?? {} };
+      await context.route("**/*", async (route) => {
+        const url = route.request().url();
+        const decision = await decideRequest(url, policy, counter);
+        if (decision.allow) await route.continue();
+        else await route.abort("blockedbyclient");
+      });
+      const page = await context.newPage();
+      const errors = [];
+      page.on("pageerror", (e) => errors.push(String(e)));
+      await page.setContent(BLANK_HTML, { waitUntil: "load" });
+      await page.addScriptTag({ content: runtime });
+      if (opts.customBlocksScript) await page.addScriptTag({ content: opts.customBlocksScript });
+      const input = {
+        template: opts.template,
+        data: opts.data ?? {},
+        theme: opts.theme,
+        dataSources: opts.dataSources ?? [],
+        now: (opts.now ?? /* @__PURE__ */ new Date()).toISOString(),
+        locale: opts.locale,
+        currency: opts.currency,
+        timeZone: opts.timeZone,
+        mode: "preview"
+      };
+      const result = await Promise.race([
+        page.evaluate(async (i) => window.BroadPaper.render(i), input),
+        new Promise((_, reject) => setTimeout(() => reject(new PdfRenderError(`Render timed out after ${timeout}ms`, "TIMEOUT")), timeout))
+      ]);
+      if (errors.length) throw new PdfRenderError(`Runtime error: ${errors[0]}`, "RUNTIME");
+      const maxPages = opts.maxPages ?? 500;
+      if (result.pages > maxPages) throw new PdfRenderError(`Document has ${result.pages} pages, more than the limit of ${maxPages}`, "TOO_MANY_PAGES");
+      await page.emulateMedia({ media: "print" });
+      const pdf = await page.pdf({
+        width: `${result.width}px`,
+        height: `${result.height}px`,
+        printBackground: true,
+        preferCSSPageSize: true,
+        margin: { top: 0, right: 0, bottom: 0, left: 0 },
+        displayHeaderFooter: false,
+        tagged: opts.tagged ?? true,
+        outline: opts.outline ?? true
+      });
+      const license = await resolveLicenseStatus(opts.license !== void 0 ? { license: opts.license } : {});
+      const finished = await applyMetadata(pdf, opts.metadata, opts.now, license);
+      return { pdf: finished, pages: result.pages, warnings: result.warnings, durationMs: Date.now() - started };
+    } catch (e) {
+      if (e instanceof PdfRenderError) throw e;
+      throw new PdfRenderError(`Browser failure: ${e.message}`, "BROWSER");
+    } finally {
+      await context?.close().catch(() => void 0);
+    }
+  }
+};
+async function applyMetadata(pdf, meta, now, license) {
+  const { PDFDocument } = await import("pdf-lib");
+  const status = license ?? await resolveLicenseStatus();
+  const doc = await PDFDocument.load(pdf, { updateMetadata: false });
+  const when = meta?.creationDate ?? now ?? /* @__PURE__ */ new Date();
+  const mark = watermarkFor(status);
+  if (mark) await stampWatermark(doc, mark);
+  doc.setProducer(producerString(status));
+  doc.setCreator("BroadPaper");
+  doc.setCreationDate(when);
+  doc.setModificationDate(when);
+  if (meta?.title) doc.setTitle(meta.title, { showInWindowTitleBar: true });
+  if (meta?.author) doc.setAuthor(meta.author);
+  if (meta?.subject) doc.setSubject(meta.subject);
+  if (meta?.keywords?.length) doc.setKeywords(meta.keywords);
+  const bytes = await doc.save({ useObjectStreams: true, addDefaultPage: false });
+  return Buffer.from(bytes);
+}
+async function renderPdf(opts) {
+  let browser = opts.browser;
+  let own = false;
+  if (!browser) {
+    const launch = opts.launch ?? defaultLaunch;
+    browser = await launch();
+    own = true;
+  }
+  try {
+    return await new PdfRenderer(browser).render(opts);
+  } finally {
+    if (own) await browser.close().catch(() => void 0);
+  }
+}
+async function defaultLaunch() {
+  let mod2;
+  try {
+    mod2 = await import("playwright").catch(() => import("playwright-core"));
+  } catch {
+    throw new PdfRenderError(
+      "The Chromium backend needs Playwright, an optional peer dependency of @broadpaper/pdf. Install playwright (or playwright-core, if you supply your own browser), or render with @broadpaper/forme, which needs no browser at all.",
+      "BROWSER"
+    );
+  }
+  return mod2.chromium.launch({ headless: true, args: ["--disable-gpu", "--font-render-hinting=none", "--disable-dev-shm-usage"] });
+}
+
+// src/server/http.ts
+import { createServer } from "http";
+function readJson(req, limit) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > limit) {
+        reject(new Error("Request body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+      } catch {
+        reject(new Error("Invalid JSON"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function send(res, status, body, headers = {}) {
+  const json = JSON.stringify(body);
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8", "content-length": Buffer.byteLength(json), ...headers });
+  res.end(json);
+}
+async function createPdfServer(opts = {}) {
+  const log = opts.log ?? (() => void 0);
+  const browser = await (opts.launch ?? defaultLaunch)();
+  const renderer = new PdfRenderer(browser);
+  const concurrency = opts.concurrency ?? 4;
+  let active = 0;
+  const queue = [];
+  const acquire = () => new Promise((resolve) => {
+    if (active < concurrency) {
+      active++;
+      resolve();
+    } else queue.push(resolve);
+  });
+  const release = () => {
+    active--;
+    const next = queue.shift();
+    if (next) {
+      active++;
+      next();
+    }
+  };
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    res.setHeader("x-content-type-options", "nosniff");
+    if (req.method === "GET" && url.pathname === "/health") return send(res, 200, { ok: true, browser: browser.isConnected(), active, queued: queue.length });
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, { "access-control-allow-origin": "*", "access-control-allow-headers": "authorization, content-type", "access-control-allow-methods": "POST, GET, OPTIONS" });
+      return res.end();
+    }
+    if (req.method !== "POST" || url.pathname !== "/render") return send(res, 404, { error: "Not found" });
+    if (opts.token) {
+      const auth = req.headers.authorization ?? "";
+      if (auth !== `Bearer ${opts.token}`) return send(res, 401, { error: "Unauthorised" });
+    }
+    let body;
+    try {
+      body = await readJson(req, opts.maxBodyBytes ?? 25 * 1024 * 1024);
+    } catch (e) {
+      return send(res, 400, { error: e.message });
+    }
+    if (!body || typeof body !== "object" || !body.template) return send(res, 400, { error: "Missing template" });
+    const serverHosts = opts.network?.allowedHosts ?? [];
+    const requested = body.network?.allowedHosts;
+    const allowedHosts = requested ? requested.filter((h) => serverHosts.includes("*") || serverHosts.includes(h)) : serverHosts;
+    await acquire();
+    const started = Date.now();
+    try {
+      const result = await renderer.render({
+        template: body.template,
+        data: body.data,
+        theme: body.theme,
+        dataSources: body.dataSources,
+        now: body.now ? new Date(body.now) : void 0,
+        locale: body.locale,
+        currency: body.currency,
+        timeZone: body.timeZone,
+        metadata: body.metadata,
+        network: { ...opts.network ?? {}, allowedHosts },
+        customBlocksScript: opts.customBlocksScript,
+        timeoutMs: opts.timeoutMs,
+        maxPages: opts.maxPages
+      });
+      log(`render ok pages=${result.pages} ms=${result.durationMs}`);
+      res.setHeader("access-control-allow-origin", "*");
+      if (body.format === "json") return send(res, 200, { pdfBase64: result.pdf.toString("base64"), pages: result.pages, warnings: result.warnings, durationMs: result.durationMs });
+      res.writeHead(200, { "content-type": "application/pdf", "content-length": result.pdf.length, "x-broadpaper-pages": String(result.pages), "x-broadpaper-warnings": String(result.warnings.length), "content-disposition": `inline; filename="${(body.metadata?.title ?? "report").replace(/[^\w.-]+/g, "_")}.pdf"` });
+      res.end(result.pdf);
+    } catch (e) {
+      const err = e;
+      log(`render failed ${err.code ?? ""} ${err.message} ms=${Date.now() - started}`);
+      const status = err instanceof PdfRenderError ? err.code === "TIMEOUT" ? 504 : err.code === "TOO_MANY_PAGES" ? 413 : 500 : 500;
+      res.setHeader("access-control-allow-origin", "*");
+      send(res, status, { error: err.message, code: err.code ?? "UNKNOWN" });
+    } finally {
+      release();
+    }
+  });
+  const port = opts.port ?? 4780;
+  await new Promise((resolve) => server.listen(port, opts.host ?? "0.0.0.0", resolve));
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : port;
+  log(`BroadPaper PDF service listening on http://${opts.host ?? "0.0.0.0"}:${actualPort}`);
+  return {
+    server,
+    port: actualPort,
+    close: async () => {
+      await new Promise((resolve) => server.close(() => resolve()));
+      await browser.close().catch(() => void 0);
+    }
+  };
+}
+
+export {
+  parseLicense,
+  verifyLicense,
+  configure,
+  BroadPaper,
+  resolveLicenseStatus,
+  isPrivateAddress,
+  hostAllowed,
+  decideRequest,
+  PdfRenderError,
+  PdfRenderer,
+  applyMetadata,
+  renderPdf,
+  defaultLaunch,
+  createPdfServer
+};
+/*! Bundled license information:
+
+@noble/ed25519/index.js:
+  (*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=chunk-4YSTS7DA.js.map