@croct/sdk 0.17.8 → 0.17.10

package/cid/cachedAssigner.cjs

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cachedAssigner_exports = {};
+__export(cachedAssigner_exports, {
+  CachedAssigner: () => CachedAssigner
+});
+module.exports = __toCommonJS(cachedAssigner_exports);
+var import_logging = require("../logging");
+class CachedAssigner {
+  constructor(assigner, cache, options = {}) {
+    this.assigner = assigner;
+    this.cache = cache;
+    this.options = {
+      logger: options.logger ?? new import_logging.NullLogger(),
+      mirror: options.mirror ?? false
+    };
+  }
+  async assignCid(currentCid) {
+    const cachedCid = this.cache.get();
+    const previousCid = currentCid ?? cachedCid ?? null;
+    const { logger, mirror } = this.options;
+    if (previousCid === null) {
+      const newCid = await this.assigner.assignCid();
+      this.cache.put(newCid);
+      logger.debug("New CID stored into cache");
+      return newCid;
+    }
+    logger.debug("Using existing CID");
+    if (cachedCid !== previousCid) {
+      logger.debug("The cached CID is stale, updating cache...");
+      this.cache.put(previousCid);
+    }
+    if (mirror) {
+      logger.debug("Mirroring CID");
+      this.assigner.assignCid(previousCid).then((newCid) => {
+        if (newCid !== previousCid) {
+          logger.warn("The CID has changed, updating cache...");
+          this.cache.put(newCid);
+        }
+      }).catch(() => {
+        logger.error("Failed to mirror CID");
+      });
+    }
+    return previousCid;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CachedAssigner
+});
+//# sourceMappingURL=cachedAssigner.cjs.map

package/cid/fixedAssigner.cjs

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fixedAssigner_exports = {};
+__export(fixedAssigner_exports, {
+  FixedAssigner: () => FixedAssigner
+});
+module.exports = __toCommonJS(fixedAssigner_exports);
+class FixedAssigner {
+  constructor(cid) {
+    this.cid = cid;
+  }
+  assignCid() {
+    return Promise.resolve(this.cid);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FixedAssigner
+});
+//# sourceMappingURL=fixedAssigner.cjs.map

package/cid/index.cjs

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cid_exports = {};
+__export(cid_exports, {
+  CachedAssigner: () => import_cachedAssigner.CachedAssigner,
+  FixedAssigner: () => import_fixedAssigner.FixedAssigner,
+  RemoteAssigner: () => import_remoteAssigner.RemoteAssigner
+});
+module.exports = __toCommonJS(cid_exports);
+__reExport(cid_exports, require("./assigner"), module.exports);
+var import_cachedAssigner = require("./cachedAssigner");
+var import_fixedAssigner = require("./fixedAssigner");
+var import_remoteAssigner = require("./remoteAssigner");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CachedAssigner,
+  FixedAssigner,
+  RemoteAssigner,
+  ...require("./assigner")
+});
+//# sourceMappingURL=index.cjs.map

package/cid/remoteAssigner.cjs

@@ -0,0 +1,65 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var remoteAssigner_exports = {};
+__export(remoteAssigner_exports, {
+  RemoteAssigner: () => RemoteAssigner
+});
+module.exports = __toCommonJS(remoteAssigner_exports);
+var import_logging = require("../logging");
+var import_error = require("../error");
+var import_constants = require("../constants");
+class RemoteAssigner {
+  constructor(endpoint, logger) {
+    this.endpoint = endpoint;
+    this.logger = logger ?? new import_logging.NullLogger();
+  }
+  assignCid(currentCid) {
+    if (this.pending === void 0) {
+      this.pending = this.fetchCid(currentCid).finally(() => {
+        this.pending = void 0;
+      });
+    }
+    return this.pending;
+  }
+  async fetchCid(currentCid) {
+    const options = {
+      method: "GET",
+      credentials: "include",
+      headers: {
+        "X-Client-Library": import_constants.CLIENT_LIBRARY
+      }
+    };
+    const endpoint = new URL(this.endpoint);
+    if (currentCid !== void 0) {
+      endpoint.searchParams.set("cid", currentCid);
+    }
+    const response = await fetch(endpoint, options);
+    if (!response.ok) {
+      const error = new Error(`Failed to assign CID: ${(0, import_error.formatCause)(response.statusText)}`);
+      this.logger.error(error.message);
+      throw error;
+    }
+    this.logger.debug("New CID successfully assigned");
+    return response.text();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RemoteAssigner
+});
+//# sourceMappingURL=remoteAssigner.cjs.map

package/constants.cjs

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  BASE_ENDPOINT_URL: () => BASE_ENDPOINT_URL,
+  CLIENT_LIBRARY: () => CLIENT_LIBRARY,
+  MAX_QUERY_LENGTH: () => MAX_QUERY_LENGTH,
+  VERSION: () => VERSION
+});
+module.exports = __toCommonJS(constants_exports);
+const BASE_ENDPOINT_URL = "https://api.croct.io";
+const MAX_QUERY_LENGTH = parseInt("<@maxQueryLength@>", 10);
+const VERSION = "0.17.10";
+const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BASE_ENDPOINT_URL,
+  CLIENT_LIBRARY,
+  MAX_QUERY_LENGTH,
+  VERSION
+});
+//# sourceMappingURL=constants.cjs.map

package/constants.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/constants.ts"],"sourcesContent":["export const BASE_ENDPOINT_URL = 'https://api.croct.io';\nexport const MAX_QUERY_LENGTH = 500;\nexport const VERSION = '0.17.8';\nexport const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB,SAAS,sBAAsB,EAAE;AAC1D,MAAM,UAAU;AAChB,MAAM,iBAAiB,iBAAiB,OAAO;","names":[]}
+{"version":3,"sources":["../src/constants.ts"],"sourcesContent":["export const BASE_ENDPOINT_URL = 'https://api.croct.io';\nexport const MAX_QUERY_LENGTH = 500;\nexport const VERSION = '0.17.10';\nexport const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB,SAAS,sBAAsB,EAAE;AAC1D,MAAM,UAAU;AAChB,MAAM,iBAAiB,iBAAiB,OAAO;","names":[]}

package/constants.d.ts

@@ -1,6 +1,6 @@
 declare const BASE_ENDPOINT_URL = "https://api.croct.io";
 declare const MAX_QUERY_LENGTH: number;
-declare const VERSION = "0.17.8";
-declare const CLIENT_LIBRARY = "Croct SDK JS v0.17.8";
+declare const VERSION = "0.17.10";
+declare const CLIENT_LIBRARY = "Croct SDK JS v0.17.10";
 
 export { BASE_ENDPOINT_URL, CLIENT_LIBRARY, MAX_QUERY_LENGTH, VERSION };

package/constants.js

@@ -1,6 +1,6 @@
 const BASE_ENDPOINT_URL = "https://api.croct.io";
 const MAX_QUERY_LENGTH = parseInt("<@maxQueryLength@>", 10);
-const VERSION = "0.17.8";
+const VERSION = "0.17.10";
 const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;
 export {
   BASE_ENDPOINT_URL,

package/constants.js.map

@@ -1 +1 @@
-{"version":3,"sources":["src/constants.ts"],"sourcesContent":["export const BASE_ENDPOINT_URL = 'https://api.croct.io';\nexport const MAX_QUERY_LENGTH = 500;\nexport const VERSION = '0.17.8';\nexport const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;\n"],"mappings":"AAAO,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB,SAAS,sBAAsB,EAAE;AAC1D,MAAM,UAAU;AAChB,MAAM,iBAAiB,iBAAiB,OAAO;","names":[]}
+{"version":3,"sources":["src/constants.ts"],"sourcesContent":["export const BASE_ENDPOINT_URL = 'https://api.croct.io';\nexport const MAX_QUERY_LENGTH = 500;\nexport const VERSION = '0.17.10';\nexport const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;\n"],"mappings":"AAAO,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB,SAAS,sBAAsB,EAAE;AAC1D,MAAM,UAAU;AAChB,MAAM,iBAAiB,iBAAiB,OAAO;","names":[]}

package/container.cjs

@@ -0,0 +1,305 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var container_exports = {};
+__export(container_exports, {
+  Container: () => Container
+});
+module.exports = __toCommonJS(container_exports);
+var import_logging = require("./logging");
+var import_context = require("./context");
+var import_namespacedStorage = require("./namespacedStorage");
+var import_retry = require("./retry");
+var import_queue = require("./queue");
+var import_token = require("./token");
+var import_tracker = require("./tracker");
+var import_evaluator = require("./evaluator");
+var import_transformer = require("./transformer");
+var import_cid = require("./cid");
+var import_eventManager = require("./eventManager");
+var import_cache = require("./cache");
+var import_guaranteedChannel = require("./channel/guaranteedChannel");
+var import_channel = require("./channel");
+var import_contentFetcher = require("./contentFetcher");
+var import_cookieCache = require("./cache/cookieCache");
+var import_filteredLogger = require("./logging/filteredLogger");
+var import_httpBeaconChannel = require("./channel/httpBeaconChannel");
+const _Container = class _Container {
+  constructor(configuration) {
+    this.eventManager = new import_eventManager.SynchronousEventManager();
+    this.configuration = configuration;
+  }
+  getConfiguration() {
+    return this.configuration;
+  }
+  getEvaluator() {
+    if (this.evaluator === void 0) {
+      this.evaluator = this.createEvaluator();
+    }
+    return this.evaluator;
+  }
+  createEvaluator() {
+    return new import_evaluator.Evaluator({
+      appId: this.configuration.appId,
+      baseEndpointUrl: this.configuration.evaluationBaseEndpointUrl,
+      logger: this.getLogger("Evaluator"),
+      defaultTimeout: this.configuration.defaultFetchTimeout ?? _Container.DEFAULT_FETCH_TIMEOUT
+    });
+  }
+  getContentFetcher() {
+    if (this.contentFetcher === void 0) {
+      this.contentFetcher = this.createContentFetcher();
+    }
+    return this.contentFetcher;
+  }
+  createContentFetcher() {
+    return new import_contentFetcher.ContentFetcher({
+      appId: this.configuration.appId,
+      baseEndpointUrl: this.configuration.contentBaseEndpointUrl,
+      logger: this.getLogger("ContentFetcher"),
+      defaultTimeout: this.configuration.defaultFetchTimeout ?? _Container.DEFAULT_FETCH_TIMEOUT,
+      defaultPreferredLocale: this.configuration.defaultPreferredLocale
+    });
+  }
+  getPreviewTokenStore() {
+    if (this.previewTokenStore === void 0) {
+      this.previewTokenStore = new import_token.CachedTokenStore(
+        this.configuration.cookie?.previewToken !== void 0 ? new import_cookieCache.CookieCache(this.configuration.cookie.previewToken) : new import_cache.LocalStorageCache(this.getGlobalBrowserStorage("preview"), "token")
+      );
+    }
+    return this.previewTokenStore;
+  }
+  getTracker() {
+    if (this.tracker === void 0) {
+      this.tracker = this.createTracker();
+    }
+    return this.tracker;
+  }
+  createTracker() {
+    const context = this.getContext();
+    const tracker = new import_tracker.Tracker({
+      tab: context.getTab(),
+      tokenProvider: this.getUserTokenStore(),
+      inactivityRetryPolicy: new import_retry.ArbitraryPolicy([3e4, 3e4, 12e4, 12e4, 3e5, 3e5, 9e5]),
+      logger: this.getLogger("Tracker"),
+      channel: this.getBeaconChannel(),
+      eventMetadata: this.configuration.eventMetadata,
+      processor: this.configuration.eventProcessor === void 0 ? void 0 : this.configuration.eventProcessor(this)
+    });
+    const queue = this.getBeaconQueue();
+    queue.addCallback("halfEmpty", tracker.unsuspend);
+    queue.addCallback("full", tracker.suspend);
+    return tracker;
+  }
+  getUserTokenStore() {
+    if (this.userTokenProvider === void 0) {
+      const context = this.getContext();
+      this.userTokenProvider = {
+        getToken: context.getToken.bind(context),
+        setToken: context.setToken.bind(context)
+      };
+    }
+    return this.userTokenProvider;
+  }
+  getContext() {
+    if (this.context === void 0) {
+      this.context = this.createContext();
+    }
+    return this.context;
+  }
+  createContext() {
+    const tokenKey = this.resolveStorageNamespace("token");
+    const tabKey = this.resolveStorageNamespace("tab");
+    const browserCache = this.configuration.tokenScope === "global" && this.configuration.cookie?.userToken !== void 0 ? new import_cookieCache.CookieCache(this.configuration.cookie.userToken) : new import_cache.LocalStorageCache(this.getLocalStorage(), tokenKey);
+    const tabStorage = this.getSessionStorage();
+    if (browserCache instanceof import_cache.LocalStorageCache) {
+      this.removeTokenSyncListener = import_cache.LocalStorageCache.autoSync(browserCache);
+    }
+    return import_context.Context.load({
+      tokenScope: this.configuration.tokenScope,
+      eventDispatcher: this.getEventManager(),
+      urlSanitizer: this.configuration.urlSanitizer,
+      cache: {
+        tabId: new import_cache.LocalStorageCache(tabStorage, tabKey),
+        tabToken: new import_cache.LocalStorageCache(tabStorage, tokenKey),
+        browserToken: browserCache
+      }
+    });
+  }
+  getBeaconChannel() {
+    if (this.beaconChannel === void 0) {
+      this.beaconChannel = this.createBeaconChannel();
+    }
+    return this.beaconChannel;
+  }
+  createBeaconChannel() {
+    if (this.configuration.test) {
+      return new import_channel.SandboxChannel();
+    }
+    const channelLogger = this.getLogger("BeaconChannel");
+    const { appId, trackerEndpointUrl } = this.configuration;
+    const queuedChannel = new import_channel.QueuedChannel(
+      new import_channel.RetryChannel({
+        channel: new import_channel.GuaranteedChannel({
+          channel: new import_httpBeaconChannel.HttpBeaconChannel({
+            appId,
+            endpointUrl: trackerEndpointUrl,
+            cidAssigner: this.getCidAssigner(),
+            logger: channelLogger
+          }),
+          stamper: new import_guaranteedChannel.TimeStamper(),
+          ackTimeout: 1e4,
+          logger: channelLogger
+        }),
+        retryPolicy: new import_retry.BackoffPolicy({
+          minRetryDelay: 3e3,
+          // 3 seconds
+          maxRetryDelay: 60 * 1e3,
+          // 60 seconds
+          backoffFactor: 1.5,
+          // 1.5 ^ attempt
+          backoffJitter: 1
+          // add randomness
+        }),
+        logger: channelLogger
+      }),
+      this.getBeaconQueue(),
+      channelLogger
+    );
+    queuedChannel.flush().catch(() => {
+    });
+    return new import_channel.EncodedChannel(queuedChannel, import_transformer.encodeJson);
+  }
+  getCidAssigner() {
+    if (this.cidAssigner === void 0) {
+      this.cidAssigner = this.createCidAssigner();
+    }
+    return this.cidAssigner;
+  }
+  createCidAssigner() {
+    if (this.configuration.clientId !== void 0) {
+      return new import_cid.FixedAssigner(this.configuration.clientId);
+    }
+    if (this.configuration.test) {
+      return new import_cid.FixedAssigner("00000000-0000-0000-0000-000000000000");
+    }
+    const logger = this.getLogger("CidAssigner");
+    return new import_cid.CachedAssigner(
+      new import_cid.RemoteAssigner(this.configuration.cidAssignerEndpointUrl, logger),
+      this.configuration.cookie?.clientId !== void 0 ? new import_cookieCache.CookieCache(this.configuration.cookie?.clientId) : new import_cache.LocalStorageCache(this.getLocalStorage(), "croct.cid"),
+      {
+        logger,
+        mirror: !this.configuration.disableCidMirroring
+      }
+    );
+  }
+  getBeaconQueue() {
+    if (this.beaconQueue === void 0) {
+      this.beaconQueue = this.createBeaconQueue();
+    }
+    return this.beaconQueue;
+  }
+  createBeaconQueue() {
+    return new import_queue.MonitoredQueue(
+      new import_queue.CapacityRestrictedQueue(
+        new import_queue.PersistentQueue(this.getGlobalTabStorage("queue")),
+        this.configuration.beaconQueueSize
+      ),
+      this.getLogger("BeaconQueue")
+    );
+  }
+  getLogger(...namespace) {
+    const prefix = `Croct${namespace.length === 0 ? "" : `:${namespace.join(":")}`}`;
+    if (this.configuration.logger !== void 0) {
+      return new import_logging.NamespacedLogger(this.configuration.logger, prefix);
+    }
+    if (this.configuration.debug) {
+      return new import_logging.ConsoleLogger(prefix);
+    }
+    return import_filteredLogger.FilteredLogger.include(new import_logging.ConsoleLogger(), ["error", "warn"]);
+  }
+  getTabStorage(namespace, ...subnamespace) {
+    return this.getGlobalTabStorage("external", namespace, ...subnamespace);
+  }
+  getBrowserStorage(namespace, ...subnamespace) {
+    return this.getGlobalBrowserStorage("external", namespace, ...subnamespace);
+  }
+  getGlobalTabStorage(namespace, ...subnamespace) {
+    return new import_namespacedStorage.NamespacedStorage(
+      this.getSessionStorage(),
+      this.resolveStorageNamespace(namespace, ...subnamespace)
+    );
+  }
+  getGlobalBrowserStorage(namespace, ...subnamespace) {
+    return new import_namespacedStorage.NamespacedStorage(
+      this.getLocalStorage(),
+      this.resolveStorageNamespace(namespace, ...subnamespace)
+    );
+  }
+  resolveStorageNamespace(namespace, ...subnamespace) {
+    const { appId } = this.configuration;
+    return `croct[${appId.toLowerCase()}].${[namespace].concat(subnamespace).join(".")}`;
+  }
+  getLocalStorage() {
+    return localStorage;
+  }
+  getSessionStorage() {
+    return sessionStorage;
+  }
+  getEventManager() {
+    return this.eventManager;
+  }
+  async dispose() {
+    const logger = this.getLogger();
+    if (this.beaconChannel !== void 0) {
+      logger.debug("Closing beacon channel...");
+      await this.beaconChannel.close();
+    }
+    if (this.removeTokenSyncListener !== void 0) {
+      logger.debug("Removing token sync listener...");
+      this.removeTokenSyncListener();
+    }
+    if (this.tracker !== void 0) {
+      if (this.beaconQueue !== void 0) {
+        logger.debug("Removing queue listeners...");
+        this.beaconQueue.removeCallback("halfEmpty", this.tracker.unsuspend);
+        this.beaconQueue.removeCallback("full", this.tracker.suspend);
+      }
+      logger.debug("Suspending tracker...");
+      this.tracker.suspend();
+      await this.tracker.flushed;
+    }
+    delete this.context;
+    delete this.userTokenProvider;
+    delete this.previewTokenStore;
+    delete this.cidAssigner;
+    delete this.tracker;
+    delete this.evaluator;
+    delete this.contentFetcher;
+    delete this.beaconChannel;
+    delete this.beaconQueue;
+    delete this.removeTokenSyncListener;
+    logger.debug("Container resources released.");
+  }
+};
+_Container.DEFAULT_FETCH_TIMEOUT = 5e3;
+let Container = _Container;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Container
+});
+//# sourceMappingURL=container.cjs.map