@intlayer/analytics 9.4.2 → 9.4.4

package/dist/types/core/AnalyticsClient.d.ts

@@ -4,7 +4,7 @@ import { AnalyticsClientConfig, ContentExposureEvent, ConversionEvent, PageViewE
  * Caller-supplied fields for a page view. Everything is optional — the client
  * fills `url`, `locale`, viewport, and referrer from the environment when omitted.
  */
-type PageViewInput = {
+export type PageViewInput = {
   /** Explicit pathname / screen name (native runtimes have no `location`). */
   url?: string;
   /** Explicit locale; falls back to the client's ambient locale. */
@@ -19,21 +19,21 @@ type PageViewInput = {
   reason?: PageViewEvent['reason'];
 };
 /** Default flush cadence — one network request per 20 seconds. */
-declare const DEFAULT_FLUSH_INTERVAL = 20000;
+export declare const DEFAULT_FLUSH_INTERVAL = 20000;
 /** Default cap on distinct buffered events before an early flush. */
-declare const DEFAULT_MAX_BUFFER_SIZE = 500;
+export declare const DEFAULT_MAX_BUFFER_SIZE = 500;
 /** Default sampling — keep every session. */
-declare const DEFAULT_SAMPLE_RATE = 1;
+export declare const DEFAULT_SAMPLE_RATE = 1;
 /**
  * Maximum events per network request. `sendBeacon` and `fetch(keepalive)`
  * reject bodies over ~64KB, so large batches are split into multiple sends.
  */
-declare const MAX_EVENTS_PER_SEND = 200;
+export declare const MAX_EVENTS_PER_SEND = 200;
 /**
  * The public surface of the analytics client singleton. Framework bindings hold
  * a reference to this and forward provider/node/conversion signals into it.
  */
-type AnalyticsClient = {
+export type AnalyticsClient = {
   /** Sets the ambient locale stamped onto subsequent events. */
   setLocale: (locale: string) => void;
   /** Records a page/locale view (provider level). */
@@ -58,7 +58,6 @@ type AnalyticsClient = {
  * @param config - Resolved client configuration.
  * @returns A started-on-demand {@link AnalyticsClient}.
  */
-declare const createAnalyticsClient: (config: AnalyticsClientConfig) => AnalyticsClient;
+export declare const createAnalyticsClient: (config: AnalyticsClientConfig) => AnalyticsClient;
 //#endregion
-export { AnalyticsClient, DEFAULT_FLUSH_INTERVAL, DEFAULT_MAX_BUFFER_SIZE, DEFAULT_SAMPLE_RATE, MAX_EVENTS_PER_SEND, PageViewInput, createAnalyticsClient };
 //# sourceMappingURL=AnalyticsClient.d.ts.map

package/dist/types/core/AnalyticsClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnalyticsClient.d.ts","names":[],"sources":["../../../src/core/AnalyticsClient.ts"],"mappings":";;;;;;KAqBY;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,SAAS;;;cAIE;;cAEA;;cAEA;;;;;cAKA;;;;;KAQD;;EAEV,YAAY;;EAEZ,gBAAgB,QAAQ;;EAExB,uBACE,OAAO,KAAK,eAAe;;EAG7B,kBACE,OAAO,KAAK,eAAe;;EAG7B,aACE,uBACA,oBACA;;EAGF,QAAQ;;EAER;;EAEA;;;;;;;;;cA+BW,wBAAqB,QACxB,0BACP"}
+{"version":3,"file":"AnalyticsClient.d.ts","names":[],"sources":["../../../src/core/AnalyticsClient.ts"],"mappings":";;;;;;YAqBY;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,SAAS;;;qBAIE;;qBAEA;;qBAEA;;;;;qBAKA;;;;;YAQD;;EAEV,YAAY;;EAEZ,gBAAgB,QAAQ;;EAExB,uBACE,OAAO,KAAK,eAAe;;EAG7B,kBACE,OAAO,KAAK,eAAe;;EAG7B,aACE,uBACA,oBACA;;EAGF,QAAQ;;EAER;;EAEA;;;;;;;;;qBA+BW,wBAAqB,QACxB,0BACP"}

package/dist/types/core/abTesting.d.ts

@@ -17,7 +17,6 @@
  * assignVariant('sid-1', 'homepage-hero', ['a', 'b']);          // stable 'a' | 'b'
  * assignVariant('sid-1', 'homepage-hero', ['a', 'b'], [9, 1]);  // ~90% 'a'
  */
-declare const assignVariant: (sessionId: string, experimentKey: string, variants: string[], weights?: number[]) => string;
+export declare const assignVariant: (sessionId: string, experimentKey: string, variants: string[], weights?: number[]) => string;
 //#endregion
-export { assignVariant };
 //# sourceMappingURL=abTesting.d.ts.map

package/dist/types/core/abTesting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abTesting.d.ts","names":[],"sources":["../../../src/core/abTesting.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAoBa,gBAAa,mBACP,uBACI,oBACH"}
+{"version":3,"file":"abTesting.d.ts","names":[],"sources":["../../../src/core/abTesting.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAoBa,gBAAa,mBACP,uBACI,oBACH"}

package/dist/types/core/eventBuffer.d.ts

@@ -12,7 +12,7 @@ import { AnalyticsEvent } from "./types.js";
  *   the expendable signal). Discrete events are only dropped once no exposures
  *   remain.
  */
-type EventBuffer = {
+export type EventBuffer = {
   /** Adds an event, coalescing content exposures. Returns the current size. */
   push: (event: AnalyticsEvent) => number;
   /** Removes and returns every buffered event. */
@@ -27,9 +27,8 @@ type EventBuffer = {
  * @param options.max - Maximum number of distinct events to retain.
  * @returns A new buffer instance.
  */
-declare const createEventBuffer: ({ max }: {
+export declare const createEventBuffer: ({ max }: {
   max: number;
 }) => EventBuffer;
 //#endregion
-export { EventBuffer, createEventBuffer };
 //# sourceMappingURL=eventBuffer.d.ts.map

package/dist/types/core/eventBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eventBuffer.d.ts","names":[],"sources":["../../../src/core/eventBuffer.ts"],"mappings":";;;;;;;;;;;;;;KAgCY;;EAEV,OAAO,OAAO;;EAEd,aAAa;;EAEb;;;;;;;;;cAUW,sBAAiB;EAAe;MAAgB"}
+{"version":3,"file":"eventBuffer.d.ts","names":[],"sources":["../../../src/core/eventBuffer.ts"],"mappings":";;;;;;;;;;;;;;YAgCY;;EAEV,OAAO,OAAO;;EAEd,aAAa;;EAEb;;;;;;;;;qBAUW,sBAAiB;EAAe;MAAgB"}

package/dist/types/core/globalManager.d.ts

@@ -3,25 +3,24 @@ import { AnalyticsClient } from "./AnalyticsClient.js";
 /**
  * Returns the global analytics client, or `null` in SSR or before init.
  */
-declare const getGlobalAnalyticsClient: () => AnalyticsClient | null;
+export declare const getGlobalAnalyticsClient: () => AnalyticsClient | null;
 /**
  * Sets (or clears) the global analytics client singleton.
  *
  * @param client - The client to store globally, or `null` to clear it.
  */
-declare const setGlobalAnalyticsClient: (client: AnalyticsClient | null) => void;
+export declare const setGlobalAnalyticsClient: (client: AnalyticsClient | null) => void;
 /**
  * Increments the shared provider reference count.
  *
  * @returns The count after incrementing (`0` in SSR, where nothing is stored).
  */
-declare const incrementAnalyticsClientRefCount: () => number;
+export declare const incrementAnalyticsClientRefCount: () => number;
 /**
  * Decrements the shared provider reference count, clamping at zero.
  *
  * @returns The count after decrementing (`0` in SSR, where nothing is stored).
  */
-declare const decrementAnalyticsClientRefCount: () => number;
+export declare const decrementAnalyticsClientRefCount: () => number;
 //#endregion
-export { decrementAnalyticsClientRefCount, getGlobalAnalyticsClient, incrementAnalyticsClientRefCount, setGlobalAnalyticsClient };
 //# sourceMappingURL=globalManager.d.ts.map

package/dist/types/core/globalManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"globalManager.d.ts","names":[],"sources":["../../../src/core/globalManager.ts"],"mappings":";;;;;cA2Ba,gCAA+B;;;;;;cAU/B,2BAAwB,QAC3B;;;;;;cAWG;;;;;;cAYA"}
+{"version":3,"file":"globalManager.d.ts","names":[],"sources":["../../../src/core/globalManager.ts"],"mappings":";;;;;qBA2Ba,gCAA+B;;;;;;qBAU/B,2BAAwB,QAC3B;;;;;;qBAWG;;;;;;qBAYA"}

package/dist/types/core/initAnalyticsClient.d.ts

@@ -13,7 +13,7 @@ import { AnalyticsClient } from "./AnalyticsClient.js";
  *
  * @returns The started analytics client singleton.
  */
-declare const initAnalyticsClient: () => AnalyticsClient;
+export declare const initAnalyticsClient: () => AnalyticsClient;
 /**
  * Decrements the shared reference count and stops the global analytics client
  * only when the last provider unmounts (flushing any remaining events).
@@ -21,7 +21,6 @@ declare const initAnalyticsClient: () => AnalyticsClient;
  * Callers must pair each `stopAnalyticsClient` with a prior
  * `initAnalyticsClient` — never call it when init was skipped or cancelled.
  */
-declare const stopAnalyticsClient: () => void;
+export declare const stopAnalyticsClient: () => void;
 //#endregion
-export { initAnalyticsClient, stopAnalyticsClient };
 //# sourceMappingURL=initAnalyticsClient.d.ts.map

package/dist/types/core/initAnalyticsClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initAnalyticsClient.d.ts","names":[],"sources":["../../../src/core/initAnalyticsClient.ts"],"mappings":";;;;;;;;;;;;;;;cA4Ba,2BAA0B;;;;;;;;cA2B1B"}
+{"version":3,"file":"initAnalyticsClient.d.ts","names":[],"sources":["../../../src/core/initAnalyticsClient.ts"],"mappings":";;;;;;;;;;;;;;;qBA4Ba,2BAA0B;;;;;;;;qBA2B1B"}

package/dist/types/core/publicToken.d.ts

@@ -13,14 +13,14 @@
  * exchanges once per tab rather than once per navigation.
  */
 /** Options accepted by {@link createPublicTokenManager}. */
-type PublicTokenManagerOptions = {
+export type PublicTokenManagerOptions = {
   /** Backend base URL, without a trailing slash. */
   backendURL: string;
   /** The project's public key (`editor.clientId`). */
   clientId?: string;
 };
 /** Synchronous accessor + background refresher for the ingest token. */
-type PublicTokenManager = {
+export type PublicTokenManager = {
   /**
    * The currently valid token, or `undefined` when none has been obtained yet.
    * Never blocks and never triggers a request.
@@ -42,7 +42,6 @@ type PublicTokenManager = {
  * @param options - Backend URL and the public project key.
  * @returns A manager exposing a synchronous {@link PublicTokenManager.getToken}.
  */
-declare const createPublicTokenManager: ({ backendURL, clientId }: PublicTokenManagerOptions) => PublicTokenManager;
+export declare const createPublicTokenManager: ({ backendURL, clientId }: PublicTokenManagerOptions) => PublicTokenManager;
 //#endregion
-export { PublicTokenManager, PublicTokenManagerOptions, createPublicTokenManager };
 //# sourceMappingURL=publicToken.d.ts.map

package/dist/types/core/publicToken.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publicToken.d.ts","names":[],"sources":["../../../src/core/publicToken.ts"],"mappings":";;;;;;;;;;;;;;;KAyDY;;EAEV;;EAEA;;;KAIU;;;;;EAKV;;;;;EAKA;;;;;;;;;;;;cAaW,6BAAwB,YAAA,YAGlC,8BAA4B"}
+{"version":3,"file":"publicToken.d.ts","names":[],"sources":["../../../src/core/publicToken.ts"],"mappings":";;;;;;;;;;;;;;;YAyDY;;EAEV;;EAEA;;;YAIU;;;;;EAKV;;;;;EAKA;;;;;;;;;;;;qBAaW,6BAAwB,YAAA,YAGlC,8BAA4B"}

package/dist/types/core/sampling.d.ts

@@ -14,7 +14,6 @@
  * isSampledIn('abc', 0);   // always false
  * isSampledIn('abc', 0.5); // stable per session
  */
-declare const isSampledIn: (sessionId: string, sampleRate: number) => boolean;
+export declare const isSampledIn: (sessionId: string, sampleRate: number) => boolean;
 //#endregion
-export { isSampledIn };
 //# sourceMappingURL=sampling.d.ts.map

package/dist/types/core/sampling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampling.d.ts","names":[],"sources":["../../../src/core/sampling.ts"],"mappings":";;;;;;;;;;;;;;;;cAiBa,cAAW,mBAAqB"}
+{"version":3,"file":"sampling.d.ts","names":[],"sources":["../../../src/core/sampling.ts"],"mappings":";;;;;;;;;;;;;;;;qBAiBa,cAAW,mBAAqB"}

package/dist/types/core/session.d.ts

@@ -11,7 +11,6 @@
  *
  * @returns The stable session id for the lifetime of the tab.
  */
-declare const getSessionId: () => string;
+export declare const getSessionId: () => string;
 //#endregion
-export { getSessionId };
 //# sourceMappingURL=session.d.ts.map

package/dist/types/core/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","names":[],"sources":["../../../src/core/session.ts"],"mappings":";;;;;;;;;;;;;cAkCa"}
+{"version":3,"file":"session.d.ts","names":[],"sources":["../../../src/core/session.ts"],"mappings":";;;;;;;;;;;;;qBAkCa"}

package/dist/types/core/transport.d.ts

@@ -23,10 +23,9 @@ import { AnalyticsIngestBody } from "./types.js";
  *   the body.
  * @returns `true` when a send was dispatched, `false` otherwise.
  */
-declare const sendEvents: (endpoint: string, body: AnalyticsIngestBody, { useBeacon, token }?: {
+export declare const sendEvents: (endpoint: string, body: AnalyticsIngestBody, { useBeacon, token }?: {
   useBeacon?: boolean;
   token?: string;
 }) => boolean;
 //#endregion
-export { sendEvents };
 //# sourceMappingURL=transport.d.ts.map

package/dist/types/core/transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transport.d.ts","names":[],"sources":["../../../src/core/transport.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;cAyBa,aAAU,kBACL,MACV,uBAAmB,WAAA;EACO;EAAqB"}
+{"version":3,"file":"transport.d.ts","names":[],"sources":["../../../src/core/transport.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;qBAyBa,aAAU,kBACL,MACV,uBAAmB,WAAA;EACO;EAAqB"}

package/dist/types/core/types.d.ts

@@ -7,11 +7,11 @@
 /**
  * The kind of signal an event carries.
  */
-type AnalyticsEventType = 'page_view' | 'content_exposure' | 'conversion';
+export type AnalyticsEventType = 'page_view' | 'content_exposure' | 'conversion';
 /**
  * Fields present on every event regardless of its type.
  */
-type BaseAnalyticsEvent = {
+export type BaseAnalyticsEvent = {
   /** Client timestamp in milliseconds since epoch. */
   t: number;
   /** Current locale being displayed when the event was captured. */
@@ -23,7 +23,7 @@ type BaseAnalyticsEvent = {
  * A page/locale level event, emitted at the provider level on first mount,
  * on client-side navigation, and on locale change.
  */
-type PageViewEvent = BaseAnalyticsEvent & {
+export type PageViewEvent = BaseAnalyticsEvent & {
   type: 'page_view';
   /** Referrer host only (never the full URL) — omitted when unavailable. */
   ref?: string;
@@ -39,7 +39,7 @@ type PageViewEvent = BaseAnalyticsEvent & {
  * resolved for display. Coalesced by the buffer so repeated exposures of the
  * same node within a flush window collapse into a single event with a `count`.
  */
-type ContentExposureEvent = BaseAnalyticsEvent & {
+export type ContentExposureEvent = BaseAnalyticsEvent & {
   type: 'content_exposure';
   /** The dictionary the resolved node belongs to. */
   dictionaryKey: string;
@@ -57,7 +57,7 @@ type ContentExposureEvent = BaseAnalyticsEvent & {
 /**
  * A conversion event tying a goal to the A/B variant the session was exposed to.
  */
-type ConversionEvent = BaseAnalyticsEvent & {
+export type ConversionEvent = BaseAnalyticsEvent & {
   type: 'conversion';
   /** The experiment this conversion is attributed to. */
   experimentKey: string;
@@ -71,19 +71,19 @@ type ConversionEvent = BaseAnalyticsEvent & {
 /**
  * The union of every event the client can emit.
  */
-type AnalyticsEvent = PageViewEvent | ContentExposureEvent | ConversionEvent;
+export type AnalyticsEvent = PageViewEvent | ContentExposureEvent | ConversionEvent;
 /**
  * An event as it is handed to the client trackers, before the buffer stamps the
  * shared `BaseAnalyticsEvent` fields (`t`, `url`, and the ambient `locale`).
  */
-type TrackableEvent<E extends AnalyticsEvent = AnalyticsEvent> = Omit<E, 't' | 'url' | 'locale'> & {
+export type TrackableEvent<E extends AnalyticsEvent = AnalyticsEvent> = Omit<E, 't' | 'url' | 'locale'> & {
   /** Optional explicit locale; falls back to the client's ambient locale. */
   locale?: string;
 };
 /**
  * The batched request body sent to `POST /api/analytics/events`.
  */
-type AnalyticsIngestBody = {
+export type AnalyticsIngestBody = {
   /**
    * Short-lived, ingest-scoped token obtained by exchanging the public
    * `clientId`. Sent in the body rather than an `Authorization` header because
@@ -108,7 +108,7 @@ type AnalyticsIngestBody = {
  * Resolved runtime options for the analytics client. All values have safe
  * defaults so the client can run with only a `backendURL`.
  */
-type AnalyticsClientConfig = {
+export type AnalyticsClientConfig = {
   /** Base URL of the Intlayer backend — reused from `editor.backendURL`. */
   backendURL: string;
   /** Public project key — reused from `editor.clientId`. */
@@ -121,5 +121,4 @@ type AnalyticsClientConfig = {
   sampleRate: number;
 };
 //#endregion
-export { AnalyticsClientConfig, AnalyticsEvent, AnalyticsEventType, AnalyticsIngestBody, BaseAnalyticsEvent, ContentExposureEvent, ConversionEvent, PageViewEvent, TrackableEvent };
 //# sourceMappingURL=types.d.ts.map

package/dist/types/core/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/core/types.ts"],"mappings":";;;;;;;;;KASY;;;;KAQA;;EAEV;;EAEA;;EAEA;;;;;;KAOU,gBAAgB;EAC1B;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;KAQU,uBAAuB;EACjC;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;KAMU,kBAAkB;EAC5B;;EAEA;;EAEA;;EAEA;;EAEA;;;;;KAMU,iBACR,gBACA,uBACA;;;;;KAMQ,eAAe,UAAU,iBAAiB,kBAAkB,KACtE;;EAIA;;;;;KAMU;;;;;;;EAOV;;;;;;EAMA;;EAEA;;EAEA;;EAEA,QAAQ;;;;;;KAOE;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/core/types.ts"],"mappings":";;;;;;;;;YASY;;;;YAQA;;EAEV;;EAEA;;EAEA;;;;;;YAOU,gBAAgB;EAC1B;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;YAQU,uBAAuB;EACjC;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;YAMU,kBAAkB;EAC5B;;EAEA;;EAEA;;EAEA;;EAEA;;;;;YAMU,iBACR,gBACA,uBACA;;;;;YAMQ,eAAe,UAAU,iBAAiB,kBAAkB,KACtE;;EAIA;;;;;YAMU;;;;;;;EAOV;;;;;;EAMA;;EAEA;;EAEA;;EAEA,QAAQ;;;;;;YAOE;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA"}

package/dist/types/events/contentExposure.d.ts

@@ -15,7 +15,7 @@ import { KeyPath } from "@intlayer/types/keyPath";
  * serializeKeyPath([{ type: 'object', key: 'faq' }, { type: 'array', key: 2 }]);
  * // "faq.2"
  */
-declare const serializeKeyPath: (keyPath: KeyPath[]) => string;
+export declare const serializeKeyPath: (keyPath: KeyPath[]) => string;
 /**
  * Builds a content-exposure payload from interpreter node metadata. Shared by
  * every framework binding's analytics node plugin so the wire shape stays
@@ -24,7 +24,7 @@ declare const serializeKeyPath: (keyPath: KeyPath[]) => string;
  * @param params - Node metadata available on `NodeProps`.
  * @returns A trackable content-exposure event (minus buffer-stamped fields).
  */
-declare const buildContentExposure: (params: {
+export declare const buildContentExposure: (params: {
   dictionaryKey: string;
   keyPath: KeyPath[];
   locale?: string;
@@ -33,5 +33,4 @@ declare const buildContentExposure: (params: {
   variant?: string;
 }) => Omit<TrackableEvent<ContentExposureEvent>, 'type'>;
 //#endregion
-export { buildContentExposure, serializeKeyPath };
 //# sourceMappingURL=contentExposure.d.ts.map

package/dist/types/events/contentExposure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contentExposure.d.ts","names":[],"sources":["../../../src/events/contentExposure.ts"],"mappings":";;;;;;;;;;;;;;;;;cAiBa,mBAAgB,SAAa;;;;;;;;;cAa7B,uBAAoB;EAC/B;EACA,SAAS;EACT;EACA;EACA;EACA;MACE,KAAK,eAAe"}
+{"version":3,"file":"contentExposure.d.ts","names":[],"sources":["../../../src/events/contentExposure.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAiBa,mBAAgB,SAAa;;;;;;;;;qBAa7B,uBAAoB;EAC/B;EACA,SAAS;EACT;EACA;EACA;EACA;MACE,KAAK,eAAe"}

package/dist/types/isEnabled.d.ts

@@ -13,7 +13,6 @@
  * - we are the top window (not embedded in the editor), and
  * - the visitor is not a bot, crawler or automation runtime.
  */
-declare const isEnabled: boolean;
+export declare const isEnabled: boolean;
 //#endregion
-export { isEnabled };
 //# sourceMappingURL=isEnabled.d.ts.map

package/dist/types/isEnabled.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isEnabled.d.ts","names":[],"sources":["../../src/isEnabled.ts"],"mappings":";;;;;;;;;;;;;;;cA0Ba"}
+{"version":3,"file":"isEnabled.d.ts","names":[],"sources":["../../src/isEnabled.ts"],"mappings":";;;;;;;;;;;;;;;qBA0Ba"}

package/dist/types/utils/hash.d.ts

@@ -10,7 +10,6 @@
  * @example
  * hashString('session-1:homepage-hero'); // 3039336720
  */
-declare const hashString: (input: string) => number;
+export declare const hashString: (input: string) => number;
 //#endregion
-export { hashString };
 //# sourceMappingURL=hash.d.ts.map

package/dist/types/utils/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","names":[],"sources":["../../../src/utils/hash.ts"],"mappings":";;;;;;;;;;;;cAWa,aAAU"}
+{"version":3,"file":"hash.d.ts","names":[],"sources":["../../../src/utils/hash.ts"],"mappings":";;;;;;;;;;;;qBAWa,aAAU"}

package/dist/types/utils/idle.d.ts

@@ -9,7 +9,6 @@
  * @example
  * onIdle(() => attachVisibilityListeners());
  */
-declare const onIdle: (callback: () => void) => void;
+export declare const onIdle: (callback: () => void) => void;
 //#endregion
-export { onIdle };
 //# sourceMappingURL=idle.d.ts.map

package/dist/types/utils/idle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"idle.d.ts","names":[],"sources":["../../../src/utils/idle.ts"],"mappings":";;;;;;;;;;;cAUa,SAAM"}
+{"version":3,"file":"idle.d.ts","names":[],"sources":["../../../src/utils/idle.ts"],"mappings":";;;;;;;;;;;qBAUa,SAAM"}

package/dist/types/utils/isBot.d.ts

@@ -19,7 +19,7 @@
  * - social link-preview fetchers
  * - AI / LLM crawlers and agents
  */
-declare const BOT_USER_AGENT_PATTERN: RegExp;
+export declare const BOT_USER_AGENT_PATTERN: RegExp;
 /**
  * Tells whether a user agent string identifies a bot, crawler or automation
  * runtime rather than a human visitor.
@@ -34,7 +34,7 @@ declare const BOT_USER_AGENT_PATTERN: RegExp;
  * isBotUserAgent('Mozilla/5.0 (compatible; Googlebot/2.1)'); // true
  * isBotUserAgent('Mozilla/5.0 (Macintosh) Chrome/120'); // false
  */
-declare const isBotUserAgent: (userAgent?: string | null) => boolean;
+export declare const isBotUserAgent: (userAgent?: string | null) => boolean;
 /**
  * Tells whether the current browser environment is automated, combining the
  * user agent with automation fingerprints (`navigator.webdriver`, runtime
@@ -48,7 +48,6 @@ declare const isBotUserAgent: (userAgent?: string | null) => boolean;
  * @example
  * if (isBotEnvironment()) return; // never start the client for a crawler
  */
-declare const isBotEnvironment: () => boolean;
+export declare const isBotEnvironment: () => boolean;
 //#endregion
-export { BOT_USER_AGENT_PATTERN, isBotEnvironment, isBotUserAgent };
 //# sourceMappingURL=isBot.d.ts.map

package/dist/types/utils/isBot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isBot.d.ts","names":[],"sources":["../../../src/utils/isBot.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;cA4Ba,wBAAsB;;;;;;;;;;;;;;;cAiBtB,iBAAc;;;;;;;;;;;;;;cAmCd"}
+{"version":3,"file":"isBot.d.ts","names":[],"sources":["../../../src/utils/isBot.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;qBA4Ba,wBAAsB;;;;;;;;;;;;;;;qBAiBtB,iBAAc;;;;;;;;;;;;;;qBAmCd"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/analytics",
-  "version": "9.4.2",
+  "version": "9.4.4",
   "private": false,
   "description": "Collects which Intlayer content is shown (page/locale + node-level) and powers content A/B testing. Optional, lazily-imported companion to @intlayer/editor.",
   "keywords": [
@@ -85,9 +85,9 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.4.2",
-    "@intlayer/core": "9.4.2",
-    "@intlayer/types": "9.4.2"
+    "@intlayer/config": "9.4.4",
+    "@intlayer/core": "9.4.4",
+    "@intlayer/types": "9.4.4"
   },
   "devDependencies": {
     "@types/node": "26.4.1",
@@ -95,9 +95,9 @@
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "engines": {
     "node": ">=14.18"