@zeroad.network/token 0.13.12 → 0.14.0

package/dist/{browser-BiNZ2c6t.d.cts → browser-Bl2JEJGW.d.cts}

@@ -8,7 +8,7 @@ declare const ZEROAD_NETWORK_PUBLIC_KEY: string;
  * IMPORTANT: Requirements listed for each feature class MUST be fulfilled fully.
  * Failure to comply will result in the site getting banned from Zero Ad Network platform.
  */
-declare enum FEATURES {
+declare enum FEATURE {
     /**
      * Feature requirements:
      *  - Disable all advertisements on the page;
@@ -24,10 +24,10 @@ declare enum FEATURES {
      */
     ONE_PASS = 2
 }
-declare enum SERVER_HEADERS {
+declare enum SERVER_HEADER {
     WELCOME = "X-Better-Web-Welcome"
 }
-declare enum CLIENT_HEADERS {
+declare enum CLIENT_HEADER {
     HELLO = "X-Better-Web-Hello"
 }
 declare enum PROTOCOL_VERSION {
@@ -35,13 +35,13 @@ declare enum PROTOCOL_VERSION {
 }
 declare const CURRENT_PROTOCOL_VERSION = PROTOCOL_VERSION.V_1;
 
-declare function encodeServerHeader(clientId: string, features: FEATURES[]): string;
+declare function encodeServerHeader(clientId: string, features: FEATURE[]): string;
 type WelcomeHeader = {
     clientId: string;
     version: PROTOCOL_VERSION;
-    features: (keyof typeof FEATURES)[];
+    features: (keyof typeof FEATURE)[];
 };
 declare function decodeServerHeader(headerValue: string | null | undefined): WelcomeHeader | undefined;
 
-export { CLIENT_HEADERS as C, FEATURES as F, PROTOCOL_VERSION as P, SERVER_HEADERS as S, ZEROAD_NETWORK_PUBLIC_KEY as Z, CURRENT_PROTOCOL_VERSION as a, decodeServerHeader as d, encodeServerHeader as e };
+export { CLIENT_HEADER as C, FEATURE as F, PROTOCOL_VERSION as P, SERVER_HEADER as S, ZEROAD_NETWORK_PUBLIC_KEY as Z, CURRENT_PROTOCOL_VERSION as a, decodeServerHeader as d, encodeServerHeader as e };
 export type { WelcomeHeader as W };

package/dist/{browser-BiNZ2c6t.d.mts → browser-Bl2JEJGW.d.mts}

@@ -8,7 +8,7 @@ declare const ZEROAD_NETWORK_PUBLIC_KEY: string;
  * IMPORTANT: Requirements listed for each feature class MUST be fulfilled fully.
  * Failure to comply will result in the site getting banned from Zero Ad Network platform.
  */
-declare enum FEATURES {
+declare enum FEATURE {
     /**
      * Feature requirements:
      *  - Disable all advertisements on the page;
@@ -24,10 +24,10 @@ declare enum FEATURES {
      */
     ONE_PASS = 2
 }
-declare enum SERVER_HEADERS {
+declare enum SERVER_HEADER {
     WELCOME = "X-Better-Web-Welcome"
 }
-declare enum CLIENT_HEADERS {
+declare enum CLIENT_HEADER {
     HELLO = "X-Better-Web-Hello"
 }
 declare enum PROTOCOL_VERSION {
@@ -35,13 +35,13 @@ declare enum PROTOCOL_VERSION {
 }
 declare const CURRENT_PROTOCOL_VERSION = PROTOCOL_VERSION.V_1;
 
-declare function encodeServerHeader(clientId: string, features: FEATURES[]): string;
+declare function encodeServerHeader(clientId: string, features: FEATURE[]): string;
 type WelcomeHeader = {
     clientId: string;
     version: PROTOCOL_VERSION;
-    features: (keyof typeof FEATURES)[];
+    features: (keyof typeof FEATURE)[];
 };
 declare function decodeServerHeader(headerValue: string | null | undefined): WelcomeHeader | undefined;
 
-export { CLIENT_HEADERS as C, FEATURES as F, PROTOCOL_VERSION as P, SERVER_HEADERS as S, ZEROAD_NETWORK_PUBLIC_KEY as Z, CURRENT_PROTOCOL_VERSION as a, decodeServerHeader as d, encodeServerHeader as e };
+export { CLIENT_HEADER as C, FEATURE as F, PROTOCOL_VERSION as P, SERVER_HEADER as S, ZEROAD_NETWORK_PUBLIC_KEY as Z, CURRENT_PROTOCOL_VERSION as a, decodeServerHeader as d, encodeServerHeader as e };
 export type { WelcomeHeader as W };

package/dist/{browser-A5-3SGMN.cjs → browser-D3BXUIiT.cjs}

@@ -12,43 +12,41 @@ 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);
   }
 }
 
 const ZEROAD_NETWORK_PUBLIC_KEY = "MCowBQYDK2VwAyEAignXRaTQtxEDl4ThULucKNQKEEO2Lo5bEO8qKwjSDVs=";
-var FEATURES = /* @__PURE__ */ ((FEATURES2) => {
-  FEATURES2[FEATURES2["CLEAN_WEB"] = 1] = "CLEAN_WEB";
-  FEATURES2[FEATURES2["ONE_PASS"] = 2] = "ONE_PASS";
-  return FEATURES2;
-})(FEATURES || {});
-var SERVER_HEADERS = /* @__PURE__ */ ((SERVER_HEADERS2) => {
-  SERVER_HEADERS2["WELCOME"] = "X-Better-Web-Welcome";
-  return SERVER_HEADERS2;
-})(SERVER_HEADERS || {});
-var CLIENT_HEADERS = /* @__PURE__ */ ((CLIENT_HEADERS2) => {
-  CLIENT_HEADERS2["HELLO"] = "X-Better-Web-Hello";
-  return CLIENT_HEADERS2;
-})(CLIENT_HEADERS || {});
+var FEATURE = /* @__PURE__ */ ((FEATURE2) => {
+  FEATURE2[FEATURE2["CLEAN_WEB"] = 1] = "CLEAN_WEB";
+  FEATURE2[FEATURE2["ONE_PASS"] = 2] = "ONE_PASS";
+  return FEATURE2;
+})(FEATURE || {});
+var SERVER_HEADER = /* @__PURE__ */ ((SERVER_HEADER2) => {
+  SERVER_HEADER2["WELCOME"] = "X-Better-Web-Welcome";
+  return SERVER_HEADER2;
+})(SERVER_HEADER || {});
+var CLIENT_HEADER = /* @__PURE__ */ ((CLIENT_HEADER2) => {
+  CLIENT_HEADER2["HELLO"] = "X-Better-Web-Hello";
+  return CLIENT_HEADER2;
+})(CLIENT_HEADER || {});
 var PROTOCOL_VERSION = /* @__PURE__ */ ((PROTOCOL_VERSION2) => {
   PROTOCOL_VERSION2[PROTOCOL_VERSION2["V_1"] = 1] = "V_1";
   return 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(FEATURES)) {
-    if (!isNaN(Number(key))) continue;
-    const typedKey = key;
-    cachedFeatures.set(typedKey, FEATURES[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,28 +59,30 @@ 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 = "^";
-const validFeatureValues = Object.values(FEATURES).filter((key) => !isNaN(Number(key)));
-const validFeatureKeys = Object.values(FEATURES).filter((key) => isNaN(Number(key)));
+const validFeatureValues = Object.values(FEATURE).filter((key) => !isNaN(Number(key)));
+const validFeatureKeys = Object.values(FEATURE).filter((key) => isNaN(Number(key)));
 function encodeServerHeader(clientId, features) {
   if (!clientId?.length) {
     throw new Error("The provided `clientId` value cannot be an empty string");
@@ -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 {
@@ -120,17 +120,16 @@ function decodeServerHeader(headerValue) {
   }
 }
 
-exports.CLIENT_HEADERS = CLIENT_HEADERS;
+exports.CLIENT_HEADER = CLIENT_HEADER;
 exports.CURRENT_PROTOCOL_VERSION = CURRENT_PROTOCOL_VERSION;
-exports.FEATURES = FEATURES;
+exports.FEATURE = FEATURE;
 exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
-exports.SERVER_HEADERS = SERVER_HEADERS;
+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--AdrX2EX.mjs → browser-VjxLaeuu.mjs}

@@ -10,43 +10,41 @@ 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);
   }
 }
 
 const ZEROAD_NETWORK_PUBLIC_KEY = "MCowBQYDK2VwAyEAignXRaTQtxEDl4ThULucKNQKEEO2Lo5bEO8qKwjSDVs=";
-var FEATURES = /* @__PURE__ */ ((FEATURES2) => {
-  FEATURES2[FEATURES2["CLEAN_WEB"] = 1] = "CLEAN_WEB";
-  FEATURES2[FEATURES2["ONE_PASS"] = 2] = "ONE_PASS";
-  return FEATURES2;
-})(FEATURES || {});
-var SERVER_HEADERS = /* @__PURE__ */ ((SERVER_HEADERS2) => {
-  SERVER_HEADERS2["WELCOME"] = "X-Better-Web-Welcome";
-  return SERVER_HEADERS2;
-})(SERVER_HEADERS || {});
-var CLIENT_HEADERS = /* @__PURE__ */ ((CLIENT_HEADERS2) => {
-  CLIENT_HEADERS2["HELLO"] = "X-Better-Web-Hello";
-  return CLIENT_HEADERS2;
-})(CLIENT_HEADERS || {});
+var FEATURE = /* @__PURE__ */ ((FEATURE2) => {
+  FEATURE2[FEATURE2["CLEAN_WEB"] = 1] = "CLEAN_WEB";
+  FEATURE2[FEATURE2["ONE_PASS"] = 2] = "ONE_PASS";
+  return FEATURE2;
+})(FEATURE || {});
+var SERVER_HEADER = /* @__PURE__ */ ((SERVER_HEADER2) => {
+  SERVER_HEADER2["WELCOME"] = "X-Better-Web-Welcome";
+  return SERVER_HEADER2;
+})(SERVER_HEADER || {});
+var CLIENT_HEADER = /* @__PURE__ */ ((CLIENT_HEADER2) => {
+  CLIENT_HEADER2["HELLO"] = "X-Better-Web-Hello";
+  return CLIENT_HEADER2;
+})(CLIENT_HEADER || {});
 var PROTOCOL_VERSION = /* @__PURE__ */ ((PROTOCOL_VERSION2) => {
   PROTOCOL_VERSION2[PROTOCOL_VERSION2["V_1"] = 1] = "V_1";
   return 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(FEATURES)) {
-    if (!isNaN(Number(key))) continue;
-    const typedKey = key;
-    cachedFeatures.set(typedKey, FEATURES[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,28 +57,30 @@ 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 = "^";
-const validFeatureValues = Object.values(FEATURES).filter((key) => !isNaN(Number(key)));
-const validFeatureKeys = Object.values(FEATURES).filter((key) => isNaN(Number(key)));
+const validFeatureValues = Object.values(FEATURE).filter((key) => !isNaN(Number(key)));
+const validFeatureKeys = Object.values(FEATURE).filter((key) => isNaN(Number(key)));
 function encodeServerHeader(clientId, features) {
   if (!clientId?.length) {
     throw new Error("The provided `clientId` value cannot be an empty string");
@@ -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_HEADERS as C, FEATURES as F, PROTOCOL_VERSION as P, SERVER_HEADERS 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.d.mts

@@ -1 +1 @@
-export { C as CLIENT_HEADERS, a as CURRENT_PROTOCOL_VERSION, F as FEATURES, P as PROTOCOL_VERSION, S as SERVER_HEADERS, W as WelcomeHeader, Z as ZEROAD_NETWORK_PUBLIC_KEY, d as decodeServerHeader } from './browser-BiNZ2c6t.mjs';
+export { C as CLIENT_HEADER, a as CURRENT_PROTOCOL_VERSION, F as FEATURE, P as PROTOCOL_VERSION, S as SERVER_HEADER, W as WelcomeHeader, Z as ZEROAD_NETWORK_PUBLIC_KEY, d as decodeServerHeader } from './browser-Bl2JEJGW.mjs';

package/dist/browser.mjs

@@ -1 +1 @@
-export { C as CLIENT_HEADERS, b as CURRENT_PROTOCOL_VERSION, F as FEATURES, P as PROTOCOL_VERSION, S as SERVER_HEADERS, Z as ZEROAD_NETWORK_PUBLIC_KEY, d as decodeServerHeader } from './browser--AdrX2EX.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-A5-3SGMN.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 FEATURES_TO_ACTIONS = {
-  [browser.FEATURES.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.FEATURES.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(FEATURES_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,32 +244,36 @@ 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_HEADERS.HELLO.toLowerCase(),
-    SERVER_HEADER_NAME: browser.SERVER_HEADERS.WELCOME,
+    CLIENT_HEADER_NAME: browser.CLIENT_HEADER.HELLO.toLowerCase(),
+    SERVER_HEADER_NAME: browser.SERVER_HEADER.WELCOME,
     SERVER_HEADER_VALUE: serverHeaderValue
   };
 }
 
-exports.CLIENT_HEADERS = browser.CLIENT_HEADERS;
+exports.CLIENT_HEADER = browser.CLIENT_HEADER;
 exports.CURRENT_PROTOCOL_VERSION = browser.CURRENT_PROTOCOL_VERSION;
-exports.FEATURES = browser.FEATURES;
+exports.FEATURE = browser.FEATURE;
 exports.PROTOCOL_VERSION = browser.PROTOCOL_VERSION;
-exports.SERVER_HEADERS = browser.SERVER_HEADERS;
+exports.SERVER_HEADER = browser.SERVER_HEADER;
 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;