@formo/analytics 1.35.2 → 1.36.0

package/dist/cjs/src/queue/EventQueue.d.ts

@@ -28,6 +28,8 @@ export declare class EventQueue implements IEventQueue {
     private pendingFlush;
     private payloadHashes;
     private canSend?;
+    private closed;
+    private disposePageLeave;
     constructor(writeKey: string, options: Options);
     private generateMessageId;
     /**
@@ -35,6 +37,26 @@ export declare class EventQueue implements IEventQueue {
      * withdrawal / SDK teardown so nothing buffered can be sent later.
      */
     clear(): void;
+    /**
+     * Terminal shutdown. Unlike clear(), which only empties the buffer and can
+     * be followed by more events (consent is re-granted, say), close() makes
+     * this queue permanently inert: every later enqueue() is a no-op and the
+     * page-leave listeners are removed. flush() needs no guard of its own,
+     * because a closed queue starts empty and can never be filled again.
+     *
+     * This is the guarantee a torn-down SDK instance needs. Emission decisions
+     * and the emission itself are separated by an await in many call paths
+     * (event creation is async), so guarding the *caller* cannot work: the
+     * instance may be destroyed while the continuation is in flight. Enforcing
+     * it here means no holder of a stale reference can ever send.
+     *
+     * What close() deliberately does NOT stop is a flush already in flight.
+     * Those events were accepted while the instance was alive, so they are
+     * real data; abandoning them would turn every unmount into silent loss.
+     */
+    close(): void;
+    /** True once close() has run. Exposed for teardown assertions. */
+    get isClosed(): boolean;
     enqueue(event: IFormoEvent, callback?: (...args: any) => void): Promise<void>;
     flush(callback?: (...args: any) => void, drainAll?: boolean): Promise<void | IFormoEventFlushPayload[]>;
     /**
@@ -58,6 +80,12 @@ export declare class EventQueue implements IEventQueue {
     private sendBatches;
     private isErrorRetryable;
     private isDuplicate;
+    /**
+     * Installs the page-leave listeners and returns a disposer that removes
+     * every one of them. Without the disposer each SDK instance leaked five
+     * listeners (three on the global, two on the document) that kept the
+     * instance and its queue alive for the life of the page.
+     */
     private onPageLeave;
 }
 export {};

package/dist/cjs/src/queue/EventQueue.js

@@ -89,11 +89,23 @@ var EventQueue = /** @class */ (function () {
         this.queue = [];
         this.queueByteSize = 0; // running total of queued items' byteSize
         this.payloadHashes = new Set();
+        // Terminal shutdown flag. Once set, enqueue() and flush() are no-ops for
+        // the rest of this instance's life. See close().
+        this.closed = false;
+        // Undoes the page-leave listeners installed in the constructor.
+        this.disposePageLeave = null;
+        /**
+         * Installs the page-leave listeners and returns a disposer that removes
+         * every one of them. Without the disposer each SDK instance leaked five
+         * listeners (three on the global, two on the document) that kept the
+         * instance and its queue alive for the life of the page.
+         */
         this.onPageLeave = function (callback) {
             // To ensure the callback is only called once even if more than one events
             // are fired at once.
             var pageLeft = false;
             var isAccessible = false;
+            var resetTimer = null;
             function handleOnLeave() {
                 if (pageLeft) {
                     return;
@@ -103,33 +115,27 @@ var EventQueue = /** @class */ (function () {
                 // Reset pageLeft on the next tick
                 // to ensure callback executes for other listeners
                 // when closing an inactive browser tab.
-                setTimeout(function () {
+                resetTimer = setTimeout(function () {
+                    resetTimer = null;
                     pageLeft = false;
                 }, 0);
             }
-            // Catches the unloading of the page (e.g., closing the tab or navigating away).
-            // Includes user actions like clicking a link, entering a new URL,
-            // refreshing the page, or closing the browser tab
-            // Note that 'pagehide' is not supported in IE.
-            // So, this is a fallback.
-            globalThis.addEventListener("beforeunload", function () {
+            var onBeforeUnload = function () {
                 isAccessible = false;
                 handleOnLeave();
-            });
-            globalThis.addEventListener("blur", function () {
+            };
+            var onBlur = function () {
                 isAccessible = true;
                 handleOnLeave();
-            });
-            globalThis.addEventListener("focus", function () {
+            };
+            var onFocus = function () {
                 pageLeft = false;
-            });
-            // Catches the page being hidden, including scenarios like closing the tab.
-            document.addEventListener("pagehide", function () {
+            };
+            var onPageHide = function () {
                 isAccessible = document.visibilityState !== "hidden";
                 handleOnLeave();
-            });
-            // Catches visibility changes, such as switching tabs or minimizing the browser.
-            document.addEventListener("visibilitychange", function () {
+            };
+            var onVisibilityChange = function () {
                 isAccessible = document.visibilityState !== "hidden";
                 if (document.visibilityState === "hidden") {
                     handleOnLeave();
@@ -137,7 +143,36 @@ var EventQueue = /** @class */ (function () {
                 else {
                     pageLeft = false;
                 }
-            });
+            };
+            // Captured at install time, not read again at removal time. Teardown can
+            // run after the host has swapped or removed these globals (a test harness
+            // replacing jsdom between specs, for one), and removing a listener from a
+            // different object than it was added to silently leaves it attached.
+            var globalTarget = globalThis;
+            var documentTarget = document;
+            // Catches the unloading of the page (e.g., closing the tab or navigating away).
+            // Includes user actions like clicking a link, entering a new URL,
+            // refreshing the page, or closing the browser tab
+            // Note that 'pagehide' is not supported in IE.
+            // So, this is a fallback.
+            globalTarget.addEventListener("beforeunload", onBeforeUnload);
+            globalTarget.addEventListener("blur", onBlur);
+            globalTarget.addEventListener("focus", onFocus);
+            // Catches the page being hidden, including scenarios like closing the tab.
+            documentTarget.addEventListener("pagehide", onPageHide);
+            // Catches visibility changes, such as switching tabs or minimizing the browser.
+            documentTarget.addEventListener("visibilitychange", onVisibilityChange);
+            return function () {
+                if (resetTimer) {
+                    clearTimeout(resetTimer);
+                    resetTimer = null;
+                }
+                globalTarget.removeEventListener("beforeunload", onBeforeUnload);
+                globalTarget.removeEventListener("blur", onBlur);
+                globalTarget.removeEventListener("focus", onFocus);
+                documentTarget.removeEventListener("pagehide", onPageHide);
+                documentTarget.removeEventListener("visibilitychange", onVisibilityChange);
+            };
         };
         options = options || {};
         this.queue = [];
@@ -157,7 +192,7 @@ var EventQueue = /** @class */ (function () {
         this.errorHandler = options.errorHandler;
         this.pendingFlush = null;
         this.timer = null;
-        this.onPageLeave(function (isAccessible) { return __awaiter(_this, void 0, void 0, function () {
+        this.disposePageLeave = this.onPageLeave(function (isAccessible) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -195,6 +230,39 @@ var EventQueue = /** @class */ (function () {
         this.queueByteSize = 0;
         this.payloadHashes.clear();
     };
+    /**
+     * Terminal shutdown. Unlike clear(), which only empties the buffer and can
+     * be followed by more events (consent is re-granted, say), close() makes
+     * this queue permanently inert: every later enqueue() is a no-op and the
+     * page-leave listeners are removed. flush() needs no guard of its own,
+     * because a closed queue starts empty and can never be filled again.
+     *
+     * This is the guarantee a torn-down SDK instance needs. Emission decisions
+     * and the emission itself are separated by an await in many call paths
+     * (event creation is async), so guarding the *caller* cannot work: the
+     * instance may be destroyed while the continuation is in flight. Enforcing
+     * it here means no holder of a stale reference can ever send.
+     *
+     * What close() deliberately does NOT stop is a flush already in flight.
+     * Those events were accepted while the instance was alive, so they are
+     * real data; abandoning them would turn every unmount into silent loss.
+     */
+    EventQueue.prototype.close = function () {
+        this.closed = true;
+        this.clear();
+        if (this.disposePageLeave) {
+            safeCall(this.disposePageLeave);
+            this.disposePageLeave = null;
+        }
+    };
+    Object.defineProperty(EventQueue.prototype, "isClosed", {
+        /** True once close() has run. Exposed for teardown assertions. */
+        get: function () {
+            return this.closed;
+        },
+        enumerable: false,
+        configurable: true
+    });
     EventQueue.prototype.enqueue = function (event, callback) {
         return __awaiter(this, void 0, void 0, function () {
             var message_id, queueItem, hasReachedFlushAt, hasReachedQueueSize;
@@ -202,6 +270,10 @@ var EventQueue = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         callback = callback || noop;
+                        // A torn-down instance must never buffer, however late the caller
+                        // arrives. See close().
+                        if (this.closed)
+                            return [2 /*return*/];
                         // Refuse to buffer anything once consent is withdrawn.
                         if (this.canSend && !this.canSend()) {
                             this.clear();
@@ -210,6 +282,12 @@ var EventQueue = /** @class */ (function () {
                         return [4 /*yield*/, this.generateMessageId(event)];
                     case 1:
                         message_id = _a.sent();
+                        // Re-check after the await. A caller that entered before close() is
+                        // suspended here, and on a queue that has not flushed yet its event
+                        // would push and flush immediately - the exact shape of the bug close()
+                        // exists to stop.
+                        if (this.closed)
+                            return [2 /*return*/];
                         // check if the message already exists
                         if (this.isDuplicate(message_id)) {
                             logger_1.logger.warn("Event already enqueued, try again after ".concat((0, utils_1.millisecondsToSecond)(this.flushIntervalMs), " seconds."));

package/dist/cjs/src/queue/type.d.ts

@@ -3,5 +3,6 @@ export interface IEventQueue {
     enqueue(event: IFormoEvent, callback?: (...args: any) => void): Promise<void>;
     flush(callback?: (...args: any) => void): Promise<any>;
     clear(): void;
+    close(): void;
 }
 //# sourceMappingURL=type.d.ts.map

package/dist/cjs/src/tracking/TrackingPolicy.d.ts

@@ -0,0 +1,146 @@
+import { ChainID, Options } from "../types";
+/** Wallet event kinds that `autocapture` can switch on or off individually. */
+export type AutocaptureEventType = "connect" | "disconnect" | "signature" | "transaction" | "chain";
+/**
+ * What the policy knows about the event being considered.
+ *
+ * An object rather than a bare chain id on purpose. The `excludeChains` fix
+ * had to thread an explicit chain through every gate because the policy had
+ * no identity of its own, and each further per-event input would widen those
+ * signatures again. New inputs extend this type instead.
+ */
+export interface TrackingContext {
+    /**
+     * The event's own chain, when it has one. It wins over the SDK's central
+     * chain, because the two differ whenever the event did not come from the
+     * active provider: a second wallet signing through its own transport, or a
+     * wagmi mutation naming an explicit chain.
+     */
+    chainId?: ChainID;
+}
+/** What the policy needs from the SDK it advises. */
+export interface TrackingPolicyDeps {
+    /**
+     * The CURRENT options.
+     *
+     * A getter, not a captured object: `FormoAnalytics.options` is public and
+     * mutable, so a consumer can replace it after init
+     * (`formo.options = { ...formo.options, tracking: false }`). The gates used
+     * to read `this.options` on every call, so that took effect immediately,
+     * and holding the constructor's object here would silently freeze
+     * configuration at init time.
+     */
+    options(): Options;
+    /** Consent state. Separate from options because the visitor can change it. */
+    hasOptedOut(): boolean;
+    /** The SDK's central chain, used when an event carries none of its own. */
+    currentChainId(): ChainID | undefined;
+}
+export interface ITrackingPolicy {
+    shouldTrack(context?: TrackingContext): boolean;
+    isTrackingSuppressed(): boolean;
+    isChainExcluded(context?: TrackingContext): boolean;
+    isPageExcluded(): boolean;
+    isPersistedIdentityPurgeRequired(): boolean;
+    isAutocaptureEnabled(eventType: AutocaptureEventType): boolean;
+}
+/**
+ * Every "may we track this?" decision, in one place.
+ *
+ * Split out of `FormoAnalytics` so the rules can be read and tested without
+ * an SDK instance, and so option parsing happens once rather than being
+ * re-derived at each gate.
+ */
+export declare class TrackingPolicy implements ITrackingPolicy {
+    private readonly deps;
+    constructor(deps: TrackingPolicyDeps);
+    /**
+     * `tracking` as an options object, or null when it is absent, a boolean, or
+     * anything else. Every exclusion rule lives on the object form, so a null
+     * here means "no exclusions configured", not "excluded".
+     */
+    private trackingOptions;
+    /**
+     * Visitor-level tracking suppression.
+     *
+     * True when the SDK must not persist any identity/session/chain state or
+     * send any events for this visitor: an explicit opt-out, or a
+     * jurisdiction/timezone/host/path exclusion. Public entry points that write
+     * state before reaching `shouldTrack()` (identify / connect / detect) check
+     * this first, so a suppressed visitor leaves no cookies or session state.
+     */
+    isTrackingSuppressed(): boolean;
+    /**
+     * Whether the environment is excluded: the visitor's timezone, the current
+     * hostname, or the current pathname.
+     *
+     * Timezone is visitor-level and stable for the session. Host and path are
+     * current-page-level and transient, so a SPA navigating back to an allowed
+     * path resumes tracking for later actions.
+     */
+    private isEnvironmentExcluded;
+    /** Exact match against `tracking.excludeHosts`. */
+    private isHostExcluded;
+    /** Exact match against `tracking.excludePaths`. */
+    private isPathExcluded;
+    /**
+     * Case-insensitive match of the browser-resolved timezone against
+     * `tracking.excludeTimezones`. Client-side and best-effort; see the option's
+     * own documentation.
+     */
+    private isTimezoneExcluded;
+    /**
+     * Whether the CURRENT PAGE is excluded, as opposed to the visitor.
+     *
+     * Host and path exclusions are transient: identity written on an allowed
+     * page must survive a visit to an excluded route, so callers that persist
+     * or restore identity skip the work here rather than purging.
+     */
+    isPageExcluded(): boolean;
+    /**
+     * Whether a persisted identity cookie should be actively purged, not merely
+     * left unwritten.
+     *
+     * Host and path exclusions are deliberately absent: they are transient
+     * current-page states, so a cookie legitimately written on an allowed page
+     * must survive a visit to an excluded route.
+     */
+    isPersistedIdentityPurgeRequired(): boolean;
+    /**
+     * Whether the chain in play is in `tracking.excludeChains`.
+     *
+     * Separate from `shouldTrack()` so `identify()` can ask *before* mutating
+     * identity state. `trackEvent()` drops an excluded event silently, but
+     * `identify()` marks the wallet as identified first, so without this an
+     * identify on an excluded chain is dedup-marked and then discarded, and the
+     * wallet never re-emits for the rest of the session even after switching to
+     * an allowed chain. On the Privy path that loses a whole cluster at once.
+     */
+    isChainExcluded(context?: TrackingContext): boolean;
+    /**
+     * The shared chain rule, so `shouldTrack()` and `isChainExcluded()` cannot
+     * drift apart. Callers have already established that `excludeChains` is
+     * non-empty.
+     *
+     * Fails CLOSED on an unknown chain. `resolveChainIdForProvider` reports 0
+     * when it has never heard a chain from the signing wallet, and 0 is in no
+     * exclusion list, so treating it as "not excluded" would let through exactly
+     * the events an operator excluded: the wallet on the excluded chain is often
+     * the one we know least about. An explicit exclusion is a directive, so an
+     * unresolvable chain is refused.
+     *
+     * Keyed on 0 and deliberately NOT on `undefined`. 0 is the explicit "we
+     * asked and could not tell" marker. `undefined` means no chain state yet,
+     * which is a legitimate transient (the Privy path reconciles a Solana wallet
+     * through exactly that state), and refusing it would drop real events.
+     * `backfillActiveWallet()` never persists 0, so an unresolvable chain cannot
+     * leak into the central value and reach the unscoped events (page / track /
+     * identify) that fall back to it.
+     */
+    private isChainRefused;
+    /** Whether an event may be tracked at all, given consent and configuration. */
+    shouldTrack(context?: TrackingContext): boolean;
+    /** Whether a wallet event kind is enabled for autocapture. Defaults to on. */
+    isAutocaptureEnabled(eventType: AutocaptureEventType): boolean;
+}
+//# sourceMappingURL=TrackingPolicy.d.ts.map

package/dist/cjs/src/tracking/TrackingPolicy.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackingPolicy = void 0;
+var timezone_1 = require("../utils/timezone");
+var validators_1 = require("../validators");
+/**
+ * Every "may we track this?" decision, in one place.
+ *
+ * Split out of `FormoAnalytics` so the rules can be read and tested without
+ * an SDK instance, and so option parsing happens once rather than being
+ * re-derived at each gate.
+ */
+var TrackingPolicy = /** @class */ (function () {
+    function TrackingPolicy(deps) {
+        this.deps = deps;
+    }
+    /**
+     * `tracking` as an options object, or null when it is absent, a boolean, or
+     * anything else. Every exclusion rule lives on the object form, so a null
+     * here means "no exclusions configured", not "excluded".
+     */
+    TrackingPolicy.prototype.trackingOptions = function () {
+        var tracking = this.deps.options().tracking;
+        if (tracking === null ||
+            typeof tracking !== "object" ||
+            Array.isArray(tracking)) {
+            return null;
+        }
+        return tracking;
+    };
+    /**
+     * Visitor-level tracking suppression.
+     *
+     * True when the SDK must not persist any identity/session/chain state or
+     * send any events for this visitor: an explicit opt-out, or a
+     * jurisdiction/timezone/host/path exclusion. Public entry points that write
+     * state before reaching `shouldTrack()` (identify / connect / detect) check
+     * this first, so a suppressed visitor leaves no cookies or session state.
+     */
+    TrackingPolicy.prototype.isTrackingSuppressed = function () {
+        return this.deps.hasOptedOut() || this.isEnvironmentExcluded();
+    };
+    /**
+     * Whether the environment is excluded: the visitor's timezone, the current
+     * hostname, or the current pathname.
+     *
+     * Timezone is visitor-level and stable for the session. Host and path are
+     * current-page-level and transient, so a SPA navigating back to an allowed
+     * path resumes tracking for later actions.
+     */
+    TrackingPolicy.prototype.isEnvironmentExcluded = function () {
+        return (this.isTimezoneExcluded() ||
+            this.isHostExcluded() ||
+            this.isPathExcluded());
+    };
+    /** Exact match against `tracking.excludeHosts`. */
+    TrackingPolicy.prototype.isHostExcluded = function () {
+        var tracking = this.trackingOptions();
+        if (!tracking)
+            return false;
+        if (typeof window === "undefined")
+            return false;
+        var _a = tracking.excludeHosts, excludeHosts = _a === void 0 ? [] : _a;
+        return excludeHosts.includes(window.location.hostname);
+    };
+    /** Exact match against `tracking.excludePaths`. */
+    TrackingPolicy.prototype.isPathExcluded = function () {
+        var tracking = this.trackingOptions();
+        if (!tracking)
+            return false;
+        if (typeof window === "undefined")
+            return false;
+        var _a = tracking.excludePaths, excludePaths = _a === void 0 ? [] : _a;
+        return excludePaths.includes(window.location.pathname);
+    };
+    /**
+     * Case-insensitive match of the browser-resolved timezone against
+     * `tracking.excludeTimezones`. Client-side and best-effort; see the option's
+     * own documentation.
+     */
+    TrackingPolicy.prototype.isTimezoneExcluded = function () {
+        var tracking = this.trackingOptions();
+        if (!tracking)
+            return false;
+        var _a = tracking.excludeTimezones, excludeTimezones = _a === void 0 ? [] : _a;
+        if (excludeTimezones.length === 0)
+            return false;
+        var timezone = (0, timezone_1.getTimezone)();
+        if (!timezone)
+            return false;
+        var lowerTimezone = timezone.toLowerCase();
+        return excludeTimezones.some(function (tz) { return typeof tz === "string" && tz.toLowerCase() === lowerTimezone; });
+    };
+    /**
+     * Whether the CURRENT PAGE is excluded, as opposed to the visitor.
+     *
+     * Host and path exclusions are transient: identity written on an allowed
+     * page must survive a visit to an excluded route, so callers that persist
+     * or restore identity skip the work here rather than purging.
+     */
+    TrackingPolicy.prototype.isPageExcluded = function () {
+        return this.isHostExcluded() || this.isPathExcluded();
+    };
+    /**
+     * Whether a persisted identity cookie should be actively purged, not merely
+     * left unwritten.
+     *
+     * Host and path exclusions are deliberately absent: they are transient
+     * current-page states, so a cookie legitimately written on an allowed page
+     * must survive a visit to an excluded route.
+     */
+    TrackingPolicy.prototype.isPersistedIdentityPurgeRequired = function () {
+        return this.deps.hasOptedOut() || this.isTimezoneExcluded();
+    };
+    /**
+     * Whether the chain in play is in `tracking.excludeChains`.
+     *
+     * Separate from `shouldTrack()` so `identify()` can ask *before* mutating
+     * identity state. `trackEvent()` drops an excluded event silently, but
+     * `identify()` marks the wallet as identified first, so without this an
+     * identify on an excluded chain is dedup-marked and then discarded, and the
+     * wallet never re-emits for the rest of the session even after switching to
+     * an allowed chain. On the Privy path that loses a whole cluster at once.
+     */
+    TrackingPolicy.prototype.isChainExcluded = function (context) {
+        var tracking = this.trackingOptions();
+        if (!tracking)
+            return false;
+        var _a = tracking.excludeChains, excludeChains = _a === void 0 ? [] : _a;
+        if (excludeChains.length === 0)
+            return false;
+        return this.isChainRefused(excludeChains, context);
+    };
+    /**
+     * The shared chain rule, so `shouldTrack()` and `isChainExcluded()` cannot
+     * drift apart. Callers have already established that `excludeChains` is
+     * non-empty.
+     *
+     * Fails CLOSED on an unknown chain. `resolveChainIdForProvider` reports 0
+     * when it has never heard a chain from the signing wallet, and 0 is in no
+     * exclusion list, so treating it as "not excluded" would let through exactly
+     * the events an operator excluded: the wallet on the excluded chain is often
+     * the one we know least about. An explicit exclusion is a directive, so an
+     * unresolvable chain is refused.
+     *
+     * Keyed on 0 and deliberately NOT on `undefined`. 0 is the explicit "we
+     * asked and could not tell" marker. `undefined` means no chain state yet,
+     * which is a legitimate transient (the Privy path reconciles a Solana wallet
+     * through exactly that state), and refusing it would drop real events.
+     * `backfillActiveWallet()` never persists 0, so an unresolvable chain cannot
+     * leak into the central value and reach the unscoped events (page / track /
+     * identify) that fall back to it.
+     */
+    TrackingPolicy.prototype.isChainRefused = function (excludeChains, context) {
+        var _a;
+        var chainToCheck = (_a = context === null || context === void 0 ? void 0 : context.chainId) !== null && _a !== void 0 ? _a : this.deps.currentChainId();
+        if (chainToCheck === 0)
+            return true;
+        if (chainToCheck === undefined)
+            return false;
+        return excludeChains.includes(chainToCheck);
+    };
+    /** Whether an event may be tracked at all, given consent and configuration. */
+    TrackingPolicy.prototype.shouldTrack = function (context) {
+        if (this.deps.hasOptedOut())
+            return false;
+        // An explicit boolean is the whole answer; no exclusions apply to it.
+        var tracking = this.deps.options().tracking;
+        if (typeof tracking === "boolean")
+            return tracking;
+        var configured = this.trackingOptions();
+        if (configured) {
+            if (this.isEnvironmentExcluded())
+                return false;
+            var _a = configured.excludeChains, excludeChains = _a === void 0 ? [] : _a;
+            if (excludeChains.length > 0 && this.isChainRefused(excludeChains, context)) {
+                return false;
+            }
+            return true;
+        }
+        // Nothing configured: track everywhere except localhost.
+        return !(0, validators_1.isLocalhost)();
+    };
+    /** Whether a wallet event kind is enabled for autocapture. Defaults to on. */
+    TrackingPolicy.prototype.isAutocaptureEnabled = function (eventType) {
+        var autocapture = this.deps.options().autocapture;
+        if (autocapture === undefined)
+            return true;
+        if (typeof autocapture === "boolean")
+            return autocapture;
+        if (autocapture !== null && typeof autocapture === "object") {
+            // Only an explicit false disables a kind.
+            return autocapture[eventType] !== false;
+        }
+        return true;
+    };
+    return TrackingPolicy;
+}());
+exports.TrackingPolicy = TrackingPolicy;
+//# sourceMappingURL=TrackingPolicy.js.map

package/dist/cjs/src/validators/address.d.ts

@@ -1,5 +1,5 @@
 import { ValidInputTypes } from "../types";
 export declare const isAddress: (value: ValidInputTypes, checksum?: boolean) => boolean;
 export declare const checkAddressChecksum: (data: string) => boolean;
-export declare function ensureIfUint8Array<T = any>(data: T): Uint8Array<ArrayBuffer> | T;
+export declare function ensureIfUint8Array<T = any>(data: T): T | Uint8Array<ArrayBuffer>;
 //# sourceMappingURL=address.d.ts.map

package/dist/cjs/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.35.2";
+export declare const version = "1.36.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/cjs/src/version.js

@@ -3,5 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // This file is auto-generated by scripts/update-version.js during npm version
 // Do not edit manually - it will be overwritten
-exports.version = '1.35.2';
+exports.version = '1.36.0';
 //# sourceMappingURL=version.js.map