@zeroad.network/token 0.13.13 → 0.14.0

package/dist/{browser-Do--x9Sv.cjs → browser-D3BXUIiT.cjs}

@@ -12,9 +12,15 @@ function setLogLevel(level) {
     currentLevel = level;
   }
 }
+let transport = (level, ...args) => {
+  console.log(`[${level.toUpperCase()}]`, ...args);
+};
+function setLogTransport(fn) {
+  transport = fn;
+}
 function log(level, ...args) {
   if (levels[level] <= levels[currentLevel]) {
-    console.log(`[${level.toUpperCase()}]`, ...args);
+    transport(level, ...args);
   }
 }
 
@@ -38,17 +44,9 @@ var PROTOCOL_VERSION = /* @__PURE__ */ ((PROTOCOL_VERSION2) => {
 })(PROTOCOL_VERSION || {});
 const CURRENT_PROTOCOL_VERSION = 1 /* V_1 */;
 
-let cachedFeatures;
-function FEATURE_MAP() {
-  if (cachedFeatures) return cachedFeatures;
-  cachedFeatures = /* @__PURE__ */ new Map();
-  for (const key of Object.keys(FEATURE)) {
-    if (!isNaN(Number(key))) continue;
-    const typedKey = key;
-    cachedFeatures.set(typedKey, FEATURE[typedKey]);
-  }
-  return cachedFeatures;
-}
+const FEATURE_MAP = new Map(
+  Object.entries(FEATURE).filter(([k]) => isNaN(Number(k)))
+);
 function toBase64(data) {
   if (typeof data.toBase64 === "function") return data.toBase64();
   if (typeof Buffer !== "undefined") return Buffer.from(data).toString("base64");
@@ -61,23 +59,25 @@ function toBase64(data) {
   }
   throw new Error("Base64 encoding not supported in this environment");
 }
-function fromBase64(input) {
-  if (typeof Uint8Array.fromBase64 === "function") return Uint8Array.fromBase64(input);
-  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(input, "base64"));
-  if (typeof atob === "function") {
+exports.fromBase64 = void 0;
+if (typeof Uint8Array.fromBase64 === "function") exports.fromBase64 = (input) => Uint8Array.fromBase64(input);
+else if (typeof Buffer !== "undefined") exports.fromBase64 = (input) => new Uint8Array(Buffer.from(input, "base64"));
+else if (typeof atob === "function") {
+  exports.fromBase64 = (input) => {
     const binary = atob(input);
     const bytes = new Uint8Array(binary.length);
     for (let i = 0; i < binary.length; i++) {
       bytes[i] = binary.charCodeAt(i);
     }
     return bytes;
-  }
+  };
+} else {
   throw new Error("Base64 decoding not supported in this environment");
 }
 function assert(value, message) {
   if (!value) throw new Error(message);
 }
-const hasFlag = (bit, flags) => Boolean(bit & flags);
+const hasFlag = (bit, flags) => (bit & flags) !== 0;
 const setFlags = (features = []) => features.reduce((acc, feature) => acc | feature, 0);
 
 const SEPARATOR = "^";
@@ -107,7 +107,7 @@ function decodeServerHeader(headerValue) {
     );
     assert(Number(flags).toFixed(0).toString() === flags, "Invalid flags number");
     const features = [];
-    for (const [feature, bit] of FEATURE_MAP()) {
+    for (const [feature, bit] of FEATURE_MAP) {
       if (hasFlag(Number(flags), bit)) features.push(feature);
     }
     return {
@@ -128,9 +128,8 @@ exports.SERVER_HEADER = SERVER_HEADER;
 exports.ZEROAD_NETWORK_PUBLIC_KEY = ZEROAD_NETWORK_PUBLIC_KEY;
 exports.decodeServerHeader = decodeServerHeader;
 exports.encodeServerHeader = encodeServerHeader;
-exports.fromBase64 = fromBase64;
-exports.hasFlag = hasFlag;
 exports.log = log;
 exports.setFlags = setFlags;
 exports.setLogLevel = setLogLevel;
+exports.setLogTransport = setLogTransport;
 exports.toBase64 = toBase64;

package/dist/{browser-DiH4sEBn.mjs → browser-VjxLaeuu.mjs}

@@ -10,9 +10,15 @@ function setLogLevel(level) {
     currentLevel = level;
   }
 }
+let transport = (level, ...args) => {
+  console.log(`[${level.toUpperCase()}]`, ...args);
+};
+function setLogTransport(fn) {
+  transport = fn;
+}
 function log(level, ...args) {
   if (levels[level] <= levels[currentLevel]) {
-    console.log(`[${level.toUpperCase()}]`, ...args);
+    transport(level, ...args);
   }
 }
 
@@ -36,17 +42,9 @@ var PROTOCOL_VERSION = /* @__PURE__ */ ((PROTOCOL_VERSION2) => {
 })(PROTOCOL_VERSION || {});
 const CURRENT_PROTOCOL_VERSION = 1 /* V_1 */;
 
-let cachedFeatures;
-function FEATURE_MAP() {
-  if (cachedFeatures) return cachedFeatures;
-  cachedFeatures = /* @__PURE__ */ new Map();
-  for (const key of Object.keys(FEATURE)) {
-    if (!isNaN(Number(key))) continue;
-    const typedKey = key;
-    cachedFeatures.set(typedKey, FEATURE[typedKey]);
-  }
-  return cachedFeatures;
-}
+const FEATURE_MAP = new Map(
+  Object.entries(FEATURE).filter(([k]) => isNaN(Number(k)))
+);
 function toBase64(data) {
   if (typeof data.toBase64 === "function") return data.toBase64();
   if (typeof Buffer !== "undefined") return Buffer.from(data).toString("base64");
@@ -59,23 +57,25 @@ function toBase64(data) {
   }
   throw new Error("Base64 encoding not supported in this environment");
 }
-function fromBase64(input) {
-  if (typeof Uint8Array.fromBase64 === "function") return Uint8Array.fromBase64(input);
-  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(input, "base64"));
-  if (typeof atob === "function") {
+let fromBase64;
+if (typeof Uint8Array.fromBase64 === "function") fromBase64 = (input) => Uint8Array.fromBase64(input);
+else if (typeof Buffer !== "undefined") fromBase64 = (input) => new Uint8Array(Buffer.from(input, "base64"));
+else if (typeof atob === "function") {
+  fromBase64 = (input) => {
     const binary = atob(input);
     const bytes = new Uint8Array(binary.length);
     for (let i = 0; i < binary.length; i++) {
       bytes[i] = binary.charCodeAt(i);
     }
     return bytes;
-  }
+  };
+} else {
   throw new Error("Base64 decoding not supported in this environment");
 }
 function assert(value, message) {
   if (!value) throw new Error(message);
 }
-const hasFlag = (bit, flags) => Boolean(bit & flags);
+const hasFlag = (bit, flags) => (bit & flags) !== 0;
 const setFlags = (features = []) => features.reduce((acc, feature) => acc | feature, 0);
 
 const SEPARATOR = "^";
@@ -105,7 +105,7 @@ function decodeServerHeader(headerValue) {
     );
     assert(Number(flags).toFixed(0).toString() === flags, "Invalid flags number");
     const features = [];
-    for (const [feature, bit] of FEATURE_MAP()) {
+    for (const [feature, bit] of FEATURE_MAP) {
       if (hasFlag(Number(flags), bit)) features.push(feature);
     }
     return {
@@ -118,4 +118,4 @@ function decodeServerHeader(headerValue) {
   }
 }
 
-export { CLIENT_HEADER as C, FEATURE as F, PROTOCOL_VERSION as P, SERVER_HEADER as S, ZEROAD_NETWORK_PUBLIC_KEY as Z, setLogLevel as a, CURRENT_PROTOCOL_VERSION as b, decodeServerHeader as d, encodeServerHeader as e, fromBase64 as f, hasFlag as h, log as l, setFlags as s, toBase64 as t };
+export { CLIENT_HEADER as C, FEATURE as F, PROTOCOL_VERSION as P, SERVER_HEADER as S, ZEROAD_NETWORK_PUBLIC_KEY as Z, setLogLevel as a, setLogTransport as b, CURRENT_PROTOCOL_VERSION as c, decodeServerHeader as d, encodeServerHeader as e, fromBase64 as f, log as l, setFlags as s, toBase64 as t };

package/dist/browser.mjs

@@ -1 +1 @@
-export { C as CLIENT_HEADER, b as CURRENT_PROTOCOL_VERSION, F as FEATURE, P as PROTOCOL_VERSION, S as SERVER_HEADER, Z as ZEROAD_NETWORK_PUBLIC_KEY, d as decodeServerHeader } from './browser-DiH4sEBn.mjs';
+export { C as CLIENT_HEADER, c as CURRENT_PROTOCOL_VERSION, F as FEATURE, P as PROTOCOL_VERSION, S as SERVER_HEADER, Z as ZEROAD_NETWORK_PUBLIC_KEY, d as decodeServerHeader } from './browser-VjxLaeuu.mjs';

package/dist/index.cjs

@@ -1,17 +1,74 @@
 'use strict';
 
-var browser = require('./browser-Do--x9Sv.cjs');
+var browser = require('./browser-D3BXUIiT.cjs');
 var node_buffer = require('node:buffer');
 var node_crypto = require('node:crypto');
 
+const DEFAULT_CACHE_CONFIG = {
+  enabled: true,
+  maxSize: 100,
+  ttl: 5e3
+  // 5 seconds
+};
+exports.cacheConfig = { ...DEFAULT_CACHE_CONFIG };
+function configureCaching(config) {
+  if (config.ttl !== void 0 && config.ttl < 0) {
+    throw new Error("Cache TTL must be >= 0");
+  }
+  if (config.maxSize !== void 0 && config.maxSize < 1) {
+    throw new Error("Cache maxSize must be >= 1");
+  }
+  exports.cacheConfig = { ...exports.cacheConfig, ...config };
+  if (!exports.cacheConfig.enabled) {
+    headerCache.clear();
+  }
+  trimCache();
+  browser.log("debug", "Cache configuration updated", exports.cacheConfig);
+}
+function getCacheConfig() {
+  return { ...exports.cacheConfig };
+}
+const headerCache = /* @__PURE__ */ new Map();
+function trimCache() {
+  if (headerCache.size <= exports.cacheConfig.maxSize) return;
+  const entriesToRemove = headerCache.size - exports.cacheConfig.maxSize;
+  const entries = Array.from(headerCache.entries());
+  entries.sort((a, b) => {
+    if (a[1].accessCount !== b[1].accessCount) {
+      return a[1].accessCount - b[1].accessCount;
+    }
+    return a[1].timestamp - b[1].timestamp;
+  });
+  for (let i = 0; i < entriesToRemove; i++) {
+    headerCache.delete(entries[i][0]);
+  }
+}
+function cleanExpiredEntries(now) {
+  for (const [key, entry] of headerCache.entries()) {
+    if (entry.effectiveExpiry <= now) {
+      headerCache.delete(key);
+    }
+  }
+}
+
 const keyCache = /* @__PURE__ */ new Map();
 function sign(data, privateKey) {
   const key = importPrivateKey(privateKey);
-  return node_crypto.sign(null, node_buffer.Buffer.from(data), key);
+  return new Promise((resolve, reject) => {
+    node_crypto.sign(null, node_buffer.Buffer.from(data), key, (err, result) => {
+      if (err) reject(err);
+      else resolve(result);
+    });
+  });
 }
 function verify(data, signature, publicKey) {
   const key = importPublicKey(publicKey);
-  return node_crypto.verify(null, node_buffer.Buffer.from(data), key, node_buffer.Buffer.from(signature));
+  return new Promise((resolve, reject) => {
+    node_crypto.verify(null, node_buffer.Buffer.from(data), key, node_buffer.Buffer.from(signature), (err, result) => {
+      if (err) reject(err);
+      else resolve(result);
+    });
+  });
 }
 const nonce = (size) => new Uint8Array(node_crypto.randomBytes(size));
 function importPrivateKey(privateKeyBase64) {
@@ -38,55 +95,132 @@ function importPublicKey(publicKeyBase64) {
 const VERSION_BYTES = 1;
 const NONCE_BYTES = 4;
 const SEPARATOR = ".";
-const FEATURE_TO_ACTIONS = {
-  [browser.FEATURE.CLEAN_WEB]: [
+const UINT32_BYTES = 4;
+const FEATURE_TO_ACTIONS = Object.freeze({
+  [browser.FEATURE.CLEAN_WEB]: Object.freeze([
     "HIDE_ADVERTISEMENTS",
     "HIDE_COOKIE_CONSENT_SCREEN",
     "HIDE_MARKETING_DIALOGS",
     "DISABLE_NON_FUNCTIONAL_TRACKING"
-  ],
-  [browser.FEATURE.ONE_PASS]: ["DISABLE_CONTENT_PAYWALL", "ENABLE_SUBSCRIPTION_ACCESS"]
-};
-function parseClientToken(headerValue, options) {
+  ]),
+  [browser.FEATURE.ONE_PASS]: Object.freeze([
+    "DISABLE_CONTENT_PAYWALL",
+    "ENABLE_SUBSCRIPTION_ACCESS"
+  ])
+});
+const FEATURE_NUMBERS = Object.freeze([browser.FEATURE.CLEAN_WEB, browser.FEATURE.ONE_PASS]);
+const EMPTY_CONTEXT = Object.freeze({
+  HIDE_ADVERTISEMENTS: false,
+  HIDE_COOKIE_CONSENT_SCREEN: false,
+  HIDE_MARKETING_DIALOGS: false,
+  DISABLE_NON_FUNCTIONAL_TRACKING: false,
+  DISABLE_CONTENT_PAYWALL: false,
+  ENABLE_SUBSCRIPTION_ACCESS: false
+});
+function createEmptyContext() {
+  return EMPTY_CONTEXT;
+}
+async function parseClientToken(headerValue, options) {
+  if (!headerValue || Array.isArray(headerValue) && !headerValue.length) {
+    return createEmptyContext();
+  }
   const headerValueAsString = Array.isArray(headerValue) ? headerValue[0] : headerValue;
-  const data = decodeClientHeader(headerValueAsString, options.publicKey || browser.ZEROAD_NETWORK_PUBLIC_KEY);
+  const now = Date.now();
+  if (exports.cacheConfig.enabled && !options.bypassCache) {
+    const cached = headerCache.get(headerValueAsString);
+    if (cached && cached.effectiveExpiry > now) {
+      cached.accessCount++;
+      return buildContext(cached.data, options, now);
+    } else if (cached) {
+      headerCache.delete(headerValueAsString);
+    }
+  }
+  const data = await decodeClientHeader(headerValueAsString, options.publicKey || browser.ZEROAD_NETWORK_PUBLIC_KEY);
+  if (exports.cacheConfig.enabled && !options.bypassCache) {
+    const cacheTTLExpiry = now + exports.cacheConfig.ttl;
+    const tokenExpiry = data?.expiresAt.getTime() ?? 0;
+    const effectiveExpiry = tokenExpiry > 0 ? Math.min(cacheTTLExpiry, tokenExpiry) : cacheTTLExpiry;
+    headerCache.set(headerValueAsString, {
+      data,
+      timestamp: now,
+      accessCount: 1,
+      effectiveExpiry
+    });
+    if (headerCache.size > 0 && headerCache.size % 100 === 0) {
+      cleanExpiredEntries(now);
+    }
+    trimCache();
+  }
+  return buildContext(data, options, now);
+}
+function buildContext(data, options, now) {
   let flags = 0;
-  if (data && data.expiresAt.getTime() >= Date.now()) flags = data.flags;
-  if (flags && data?.clientId && data.clientId !== options.clientId) flags = 0;
-  const context = /* @__PURE__ */ new Map();
-  for (const [feature, actionNames] of Object.entries(FEATURE_TO_ACTIONS)) {
-    const decision = options.features.includes(Number(feature)) && browser.hasFlag(Number(feature), flags);
-    for (const actionName of actionNames) {
-      context.set(actionName, decision);
+  if (data && data.expiresAt.getTime() >= now) {
+    if (!data.clientId || data.clientId === options.clientId) {
+      flags = data.flags;
     }
   }
-  return Object.fromEntries(context);
+  if (!flags) {
+    return createEmptyContext();
+  }
+  const featuresSet = options.features.length <= 2 ? options.features : new Set(options.features);
+  const context = {};
+  for (let i = 0; i < FEATURE_NUMBERS.length; i++) {
+    const feature = FEATURE_NUMBERS[i];
+    const actionNames = FEATURE_TO_ACTIONS[feature];
+    const isEnabled = (Array.isArray(featuresSet) ? featuresSet.includes(feature) : featuresSet.has(feature)) && (flags & feature) !== 0;
+    const len = actionNames.length;
+    if (len > 0) context[actionNames[0]] = isEnabled;
+    if (len > 1) context[actionNames[1]] = isEnabled;
+    if (len > 2) context[actionNames[2]] = isEnabled;
+    if (len > 3) context[actionNames[3]] = isEnabled;
+  }
+  return context;
 }
-function decodeClientHeader(headerValue, publicKey) {
-  if (!headerValue?.length) return;
+async function decodeClientHeader(headerValue, publicKey) {
+  if (!headerValue?.length) return void 0;
   try {
-    const [data, signature] = headerValue.split(SEPARATOR);
+    const separatorIndex = headerValue.indexOf(SEPARATOR);
+    if (separatorIndex === -1) {
+      throw new Error("Invalid header format: missing separator");
+    }
+    const data = headerValue.substring(0, separatorIndex);
+    const signature = headerValue.substring(separatorIndex + 1);
     const dataBytes = browser.fromBase64(data);
     const signatureBytes = browser.fromBase64(signature);
-    if (!verify(dataBytes.buffer, signatureBytes.buffer, publicKey)) {
+    if (!await verify(dataBytes.buffer, signatureBytes.buffer, publicKey)) {
       throw new Error("Forged header value is provided");
     }
     const version = dataBytes[0];
-    let clientId;
     if (version === browser.PROTOCOL_VERSION.V_1) {
-      const expiresAt = as32BitNumber(dataBytes, VERSION_BYTES + NONCE_BYTES);
-      const flags = as32BitNumber(dataBytes, VERSION_BYTES + NONCE_BYTES + Uint32Array.BYTES_PER_ELEMENT);
-      const expectedByteLength = VERSION_BYTES + NONCE_BYTES + Uint32Array.BYTES_PER_ELEMENT * 2;
-      if (dataBytes.byteLength > expectedByteLength) {
-        clientId = new TextDecoder().decode(dataBytes.subarray(expectedByteLength));
+      const expectedMinLength = VERSION_BYTES + NONCE_BYTES + UINT32_BYTES * 2;
+      if (dataBytes.byteLength < expectedMinLength) {
+        throw new Error("Invalid data length");
       }
-      return { version, expiresAt: new Date(expiresAt * 1e3), flags, ...clientId && { clientId } };
+      const view = new DataView(dataBytes.buffer, dataBytes.byteOffset, dataBytes.byteLength);
+      const expiresAtOffset = VERSION_BYTES + NONCE_BYTES;
+      const flagsOffset = expiresAtOffset + UINT32_BYTES;
+      const expiresAt = view.getUint32(expiresAtOffset, true);
+      const flags = view.getUint32(flagsOffset, true);
+      let clientId;
+      if (dataBytes.byteLength > expectedMinLength) {
+        const clientIdBytes = dataBytes.subarray(expectedMinLength);
+        clientId = new TextDecoder().decode(clientIdBytes);
+      }
+      return {
+        version,
+        expiresAt: new Date(expiresAt * 1e3),
+        flags,
+        ...clientId && { clientId }
+      };
     }
+    throw new Error(`Unsupported protocol version: ${version}`);
   } catch (err) {
     browser.log("warn", "Could not decode client header value", { reason: err?.message });
+    return void 0;
   }
 }
-function encodeClientHeader(data, privateKey) {
+async function encodeClientHeader(data, privateKey) {
   const payload = mergeByteArrays([
     new Uint8Array([data.version]),
     new Uint8Array(nonce(NONCE_BYTES)),
@@ -94,7 +228,7 @@ function encodeClientHeader(data, privateKey) {
     new Uint32Array([browser.setFlags(data.features)]),
     ...data.clientId?.length ? [new Uint8Array(new TextEncoder().encode(data.clientId))] : []
   ]);
-  return [browser.toBase64(payload), browser.toBase64(new Uint8Array(sign(payload.buffer, privateKey)))].join(SEPARATOR);
+  return [browser.toBase64(payload), browser.toBase64(new Uint8Array(await sign(payload.buffer, privateKey)))].join(SEPARATOR);
 }
 function mergeByteArrays(arrays) {
   const totalLength = arrays.reduce((sum, a) => sum + a.byteLength, 0);
@@ -110,14 +244,12 @@ function mergeByteArrays(arrays) {
   }
   return data;
 }
-function as32BitNumber(byteArray, begin) {
-  const bytes = byteArray.subarray(begin, begin + Uint32Array.BYTES_PER_ELEMENT);
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  return view.getUint32(0, true);
-}
 
 function Site(options) {
   const serverHeaderValue = browser.encodeServerHeader(options.clientId, options.features);
+  if (options.cacheConfig) {
+    configureCaching(options.cacheConfig);
+  }
   return {
     parseClientToken: (headerValue) => parseClientToken(headerValue, { clientId: options.clientId, features: options.features }),
     CLIENT_HEADER_NAME: browser.CLIENT_HEADER.HELLO.toLowerCase(),
@@ -135,7 +267,13 @@ exports.ZEROAD_NETWORK_PUBLIC_KEY = browser.ZEROAD_NETWORK_PUBLIC_KEY;
 exports.decodeServerHeader = browser.decodeServerHeader;
 exports.encodeServerHeader = browser.encodeServerHeader;
 exports.setLogLevel = browser.setLogLevel;
+exports.setLogTransport = browser.setLogTransport;
 exports.Site = Site;
+exports.cleanExpiredEntries = cleanExpiredEntries;
+exports.configureCaching = configureCaching;
 exports.decodeClientHeader = decodeClientHeader;
 exports.encodeClientHeader = encodeClientHeader;
+exports.getCacheConfig = getCacheConfig;
+exports.headerCache = headerCache;
 exports.parseClientToken = parseClientToken;
+exports.trimCache = trimCache;

package/dist/index.d.cts

@@ -3,6 +3,8 @@ export { C as CLIENT_HEADER, a as CURRENT_PROTOCOL_VERSION, W as WelcomeHeader,
 
 type LogLevel = "error" | "warn" | "info" | "debug";
 declare function setLogLevel(level: LogLevel): void;
+type LogTransport = (level: LogLevel, ...args: unknown[]) => void;
+declare function setLogTransport(fn: LogTransport): void;
 
 type FEATURE_ACTION = "HIDE_ADVERTISEMENTS" | "HIDE_COOKIE_CONSENT_SCREEN" | "HIDE_MARKETING_DIALOGS" | "DISABLE_NON_FUNCTIONAL_TRACKING" | "DISABLE_CONTENT_PAYWALL" | "ENABLE_SUBSCRIPTION_ACCESS";
 type ClientHeaderValue = string | string[] | undefined;
@@ -11,33 +13,53 @@ type ParseClientTokenOptions = {
     clientId: string;
     features: FEATURE[];
     publicKey?: string;
+    bypassCache?: boolean;
 };
-declare function parseClientToken(headerValue: ClientHeaderValue, options: ParseClientTokenOptions): TokenContext;
+declare function parseClientToken(headerValue: ClientHeaderValue, options: ParseClientTokenOptions): Promise<TokenContext>;
 type DecodedClientHeader = {
     version: PROTOCOL_VERSION;
     expiresAt: Date;
     flags: number;
     clientId?: string;
 };
-declare function decodeClientHeader(headerValue: string | null | undefined, publicKey: string): DecodedClientHeader | undefined;
+declare function decodeClientHeader(headerValue: string | null | undefined, publicKey: string): Promise<DecodedClientHeader | undefined>;
 type EncodeData = {
     version: PROTOCOL_VERSION;
     expiresAt: Date;
     features: FEATURE[];
     clientId?: string;
 };
-declare function encodeClientHeader(data: EncodeData, privateKey: string): string;
+declare function encodeClientHeader(data: EncodeData, privateKey: string): Promise<string>;
+
+interface CacheConfig {
+    enabled: boolean;
+    maxSize: number;
+    ttl: number;
+}
+declare let cacheConfig: CacheConfig;
+declare function configureCaching(config: Partial<CacheConfig>): void;
+declare function getCacheConfig(): Readonly<CacheConfig>;
+interface CacheEntry {
+    data: DecodedClientHeader | undefined;
+    effectiveExpiry: number;
+    accessCount: number;
+    timestamp: number;
+}
+declare const headerCache: Map<string, CacheEntry>;
+declare function trimCache(): void;
+declare function cleanExpiredEntries(now: number): void;
 
 type SiteOptions = {
     clientId: string;
     features: FEATURE[];
+    cacheConfig?: CacheConfig;
 };
 declare function Site(options: SiteOptions): {
-    parseClientToken: (headerValue: ClientHeaderValue) => TokenContext;
+    parseClientToken: (headerValue: ClientHeaderValue) => Promise<TokenContext>;
     CLIENT_HEADER_NAME: string;
     SERVER_HEADER_NAME: SERVER_HEADER;
     SERVER_HEADER_VALUE: string;
 };
 
-export { FEATURE, PROTOCOL_VERSION, SERVER_HEADER, Site, decodeClientHeader, encodeClientHeader, parseClientToken, setLogLevel };
-export type { ClientHeaderValue, DecodedClientHeader, FEATURE_ACTION, ParseClientTokenOptions, TokenContext };
+export { FEATURE, PROTOCOL_VERSION, SERVER_HEADER, Site, cacheConfig, cleanExpiredEntries, configureCaching, decodeClientHeader, encodeClientHeader, getCacheConfig, headerCache, parseClientToken, setLogLevel, setLogTransport, trimCache };
+export type { CacheConfig, ClientHeaderValue, DecodedClientHeader, FEATURE_ACTION, ParseClientTokenOptions, TokenContext };

package/dist/index.d.mts

@@ -3,6 +3,8 @@ export { C as CLIENT_HEADER, a as CURRENT_PROTOCOL_VERSION, W as WelcomeHeader,
 
 type LogLevel = "error" | "warn" | "info" | "debug";
 declare function setLogLevel(level: LogLevel): void;
+type LogTransport = (level: LogLevel, ...args: unknown[]) => void;
+declare function setLogTransport(fn: LogTransport): void;
 
 type FEATURE_ACTION = "HIDE_ADVERTISEMENTS" | "HIDE_COOKIE_CONSENT_SCREEN" | "HIDE_MARKETING_DIALOGS" | "DISABLE_NON_FUNCTIONAL_TRACKING" | "DISABLE_CONTENT_PAYWALL" | "ENABLE_SUBSCRIPTION_ACCESS";
 type ClientHeaderValue = string | string[] | undefined;
@@ -11,33 +13,53 @@ type ParseClientTokenOptions = {
     clientId: string;
     features: FEATURE[];
     publicKey?: string;
+    bypassCache?: boolean;
 };
-declare function parseClientToken(headerValue: ClientHeaderValue, options: ParseClientTokenOptions): TokenContext;
+declare function parseClientToken(headerValue: ClientHeaderValue, options: ParseClientTokenOptions): Promise<TokenContext>;
 type DecodedClientHeader = {
     version: PROTOCOL_VERSION;
     expiresAt: Date;
     flags: number;
     clientId?: string;
 };
-declare function decodeClientHeader(headerValue: string | null | undefined, publicKey: string): DecodedClientHeader | undefined;
+declare function decodeClientHeader(headerValue: string | null | undefined, publicKey: string): Promise<DecodedClientHeader | undefined>;
 type EncodeData = {
     version: PROTOCOL_VERSION;
     expiresAt: Date;
     features: FEATURE[];
     clientId?: string;
 };
-declare function encodeClientHeader(data: EncodeData, privateKey: string): string;
+declare function encodeClientHeader(data: EncodeData, privateKey: string): Promise<string>;
+
+interface CacheConfig {
+    enabled: boolean;
+    maxSize: number;
+    ttl: number;
+}
+declare let cacheConfig: CacheConfig;
+declare function configureCaching(config: Partial<CacheConfig>): void;
+declare function getCacheConfig(): Readonly<CacheConfig>;
+interface CacheEntry {
+    data: DecodedClientHeader | undefined;
+    effectiveExpiry: number;
+    accessCount: number;
+    timestamp: number;
+}
+declare const headerCache: Map<string, CacheEntry>;
+declare function trimCache(): void;
+declare function cleanExpiredEntries(now: number): void;
 
 type SiteOptions = {
     clientId: string;
     features: FEATURE[];
+    cacheConfig?: CacheConfig;
 };
 declare function Site(options: SiteOptions): {
-    parseClientToken: (headerValue: ClientHeaderValue) => TokenContext;
+    parseClientToken: (headerValue: ClientHeaderValue) => Promise<TokenContext>;
     CLIENT_HEADER_NAME: string;
     SERVER_HEADER_NAME: SERVER_HEADER;
     SERVER_HEADER_VALUE: string;
 };
 
-export { FEATURE, PROTOCOL_VERSION, SERVER_HEADER, Site, decodeClientHeader, encodeClientHeader, parseClientToken, setLogLevel };
-export type { ClientHeaderValue, DecodedClientHeader, FEATURE_ACTION, ParseClientTokenOptions, TokenContext };
+export { FEATURE, PROTOCOL_VERSION, SERVER_HEADER, Site, cacheConfig, cleanExpiredEntries, configureCaching, decodeClientHeader, encodeClientHeader, getCacheConfig, headerCache, parseClientToken, setLogLevel, setLogTransport, trimCache };
+export type { CacheConfig, ClientHeaderValue, DecodedClientHeader, FEATURE_ACTION, ParseClientTokenOptions, TokenContext };